Left Termination proof of /tmp/tmp1OUjWq/pl5.2.2.pl

Left Termination of the query pattern turing_in_4(g, g, g, a) w.r.t. the given Prolog program could not be shown:

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

Clauses:

member(H, .(H, L)).
member(X, .(H, L)) :- member(X, L).
turing(t(X, Y, Z), S, P, t(X, Y, Z)) :- member(p(S, Y, halt, W, D), P).
turing(t(X, Y, .(R, L)), S, P, T) :- ','(member(p(S, Y, S1, W, r), P), turing(t(.(W, X), R, L), S1, P, T)).
turing(t(X, Y, []), S, P, T) :- ','(member(p(S, Y, S1, W, r), P), turing(t(.(W, X), space, []), S1, P, T)).
turing(t(.(X, L), Y, R), S, P, T) :- ','(member(p(S, Y, S1, W, l), P), turing(t(L, X, .(W, R)), S1, P, T)).
turing(t([], Y, R), S, P, T) :- ','(member(p(S, Y, S1, W, l), P), turing(t([], space, .(W, R)), S1, P, T)).

Queries:

turing(g,g,g,a).

We use the technique of [30].Transforming Prolog into the following Term Rewriting System:
Pi-finite rewrite system:
The TRS R consists of the following rules:

turing_in(t([], Y, R), S, P, T) → U9(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
member_in(X, .(H, L)) → U1(X, H, L, member_in(X, L))
member_in(H, .(H, L)) → member_out(H, .(H, L))
U1(X, H, L, member_out(X, L)) → member_out(X, .(H, L))
U9(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U10(Y, R, S, P, T, turing_in(t([], space, .(W, R)), S1, P, T))
turing_in(t(.(X, L), Y, R), S, P, T) → U7(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
U7(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U8(X, L, Y, R, S, P, T, turing_in(t(L, X, .(W, R)), S1, P, T))
turing_in(t(X, Y, []), S, P, T) → U5(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))
U5(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U6(X, Y, S, P, T, turing_in(t(.(W, X), space, []), S1, P, T))
turing_in(t(X, Y, .(R, L)), S, P, T) → U3(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
U3(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U4(X, Y, R, L, S, P, T, turing_in(t(.(W, X), R, L), S1, P, T))
turing_in(t(X, Y, Z), S, P, t(X, Y, Z)) → U2(X, Y, Z, S, P, member_in(p(S, Y, halt, W, D), P))
U2(X, Y, Z, S, P, member_out(p(S, Y, halt, W, D), P)) → turing_out(t(X, Y, Z), S, P, t(X, Y, Z))
U4(X, Y, R, L, S, P, T, turing_out(t(.(W, X), R, L), S1, P, T)) → turing_out(t(X, Y, .(R, L)), S, P, T)
U6(X, Y, S, P, T, turing_out(t(.(W, X), space, []), S1, P, T)) → turing_out(t(X, Y, []), S, P, T)
U8(X, L, Y, R, S, P, T, turing_out(t(L, X, .(W, R)), S1, P, T)) → turing_out(t(.(X, L), Y, R), S, P, T)
U10(Y, R, S, P, T, turing_out(t([], space, .(W, R)), S1, P, T)) → turing_out(t([], Y, R), S, P, T)

Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

  ↳ PrologToPiTRSProof

Pi-finite rewrite system:
The TRS R consists of the following rules:

turing_in(t([], Y, R), S, P, T) → U9(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
member_in(X, .(H, L)) → U1(X, H, L, member_in(X, L))
member_in(H, .(H, L)) → member_out(H, .(H, L))
U1(X, H, L, member_out(X, L)) → member_out(X, .(H, L))
U9(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U10(Y, R, S, P, T, turing_in(t([], space, .(W, R)), S1, P, T))
turing_in(t(.(X, L), Y, R), S, P, T) → U7(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
U7(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U8(X, L, Y, R, S, P, T, turing_in(t(L, X, .(W, R)), S1, P, T))
turing_in(t(X, Y, []), S, P, T) → U5(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))
U5(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U6(X, Y, S, P, T, turing_in(t(.(W, X), space, []), S1, P, T))
turing_in(t(X, Y, .(R, L)), S, P, T) → U3(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
U3(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U4(X, Y, R, L, S, P, T, turing_in(t(.(W, X), R, L), S1, P, T))
turing_in(t(X, Y, Z), S, P, t(X, Y, Z)) → U2(X, Y, Z, S, P, member_in(p(S, Y, halt, W, D), P))
U2(X, Y, Z, S, P, member_out(p(S, Y, halt, W, D), P)) → turing_out(t(X, Y, Z), S, P, t(X, Y, Z))
U4(X, Y, R, L, S, P, T, turing_out(t(.(W, X), R, L), S1, P, T)) → turing_out(t(X, Y, .(R, L)), S, P, T)
U6(X, Y, S, P, T, turing_out(t(.(W, X), space, []), S1, P, T)) → turing_out(t(X, Y, []), S, P, T)
U8(X, L, Y, R, S, P, T, turing_out(t(L, X, .(W, R)), S1, P, T)) → turing_out(t(.(X, L), Y, R), S, P, T)
U10(Y, R, S, P, T, turing_out(t([], space, .(W, R)), S1, P, T)) → turing_out(t([], Y, R), S, P, T)

TURING_IN(t([], Y, R), S, P, T) → U9¹(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
TURING_IN(t([], Y, R), S, P, T) → MEMBER_IN(p(S, Y, S1, W, l), P)
MEMBER_IN(X, .(H, L)) → U1¹(X, H, L, member_in(X, L))
MEMBER_IN(X, .(H, L)) → MEMBER_IN(X, L)
U9¹(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U10¹(Y, R, S, P, T, turing_in(t([], space, .(W, R)), S1, P, T))
U9¹(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → TURING_IN(t([], space, .(W, R)), S1, P, T)
TURING_IN(t(.(X, L), Y, R), S, P, T) → U7¹(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
TURING_IN(t(.(X, L), Y, R), S, P, T) → MEMBER_IN(p(S, Y, S1, W, l), P)
U7¹(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U8¹(X, L, Y, R, S, P, T, turing_in(t(L, X, .(W, R)), S1, P, T))
U7¹(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → TURING_IN(t(L, X, .(W, R)), S1, P, T)
TURING_IN(t(X, Y, []), S, P, T) → U5¹(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))
TURING_IN(t(X, Y, []), S, P, T) → MEMBER_IN(p(S, Y, S1, W, r), P)
U5¹(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U6¹(X, Y, S, P, T, turing_in(t(.(W, X), space, []), S1, P, T))
U5¹(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → TURING_IN(t(.(W, X), space, []), S1, P, T)
TURING_IN(t(X, Y, .(R, L)), S, P, T) → U3¹(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
TURING_IN(t(X, Y, .(R, L)), S, P, T) → MEMBER_IN(p(S, Y, S1, W, r), P)
U3¹(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U4¹(X, Y, R, L, S, P, T, turing_in(t(.(W, X), R, L), S1, P, T))
U3¹(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → TURING_IN(t(.(W, X), R, L), S1, P, T)
TURING_IN(t(X, Y, Z), S, P, t(X, Y, Z)) → U2¹(X, Y, Z, S, P, member_in(p(S, Y, halt, W, D), P))
TURING_IN(t(X, Y, Z), S, P, t(X, Y, Z)) → MEMBER_IN(p(S, Y, halt, W, D), P)

The TRS R consists of the following rules:

turing_in(t([], Y, R), S, P, T) → U9(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
member_in(X, .(H, L)) → U1(X, H, L, member_in(X, L))
member_in(H, .(H, L)) → member_out(H, .(H, L))
U1(X, H, L, member_out(X, L)) → member_out(X, .(H, L))
U9(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U10(Y, R, S, P, T, turing_in(t([], space, .(W, R)), S1, P, T))
turing_in(t(.(X, L), Y, R), S, P, T) → U7(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
U7(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U8(X, L, Y, R, S, P, T, turing_in(t(L, X, .(W, R)), S1, P, T))
turing_in(t(X, Y, []), S, P, T) → U5(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))
U5(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U6(X, Y, S, P, T, turing_in(t(.(W, X), space, []), S1, P, T))
turing_in(t(X, Y, .(R, L)), S, P, T) → U3(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
U3(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U4(X, Y, R, L, S, P, T, turing_in(t(.(W, X), R, L), S1, P, T))
turing_in(t(X, Y, Z), S, P, t(X, Y, Z)) → U2(X, Y, Z, S, P, member_in(p(S, Y, halt, W, D), P))
U2(X, Y, Z, S, P, member_out(p(S, Y, halt, W, D), P)) → turing_out(t(X, Y, Z), S, P, t(X, Y, Z))
U4(X, Y, R, L, S, P, T, turing_out(t(.(W, X), R, L), S1, P, T)) → turing_out(t(X, Y, .(R, L)), S, P, T)
U6(X, Y, S, P, T, turing_out(t(.(W, X), space, []), S1, P, T)) → turing_out(t(X, Y, []), S, P, T)
U8(X, L, Y, R, S, P, T, turing_out(t(L, X, .(W, R)), S1, P, T)) → turing_out(t(.(X, L), Y, R), S, P, T)
U10(Y, R, S, P, T, turing_out(t([], space, .(W, R)), S1, P, T)) → turing_out(t([], Y, R), S, P, T)

The argument filtering Pi contains the following mapping:
turing_in(x1, x2, x3, x4) = turing_in(x1, x3)
t(x1, x2, x3) = t(x1, x2, x3)
[] = []
U9(x1, x2, x3, x4, x5, x6) = U9(x2, x4, x6)
member_in(x1, x2) = member_in(x2)
p(x1, x2, x3, x4, x5) = p(x1, x2, x4, x5)
l = l
.(x1, x2) = .(x1, x2)
U1(x1, x2, x3, x4) = U1(x4)
member_out(x1, x2) = member_out(x1)
U10(x1, x2, x3, x4, x5, x6) = U10(x3, x6)
space = space
U7(x1, x2, x3, x4, x5, x6, x7, x8) = U7(x1, x2, x4, x6, x8)
U8(x1, x2, x3, x4, x5, x6, x7, x8) = U8(x5, x8)
U5(x1, x2, x3, x4, x5, x6) = U5(x1, x4, x6)
r = r
U6(x1, x2, x3, x4, x5, x6) = U6(x3, x6)
U3(x1, x2, x3, x4, x5, x6, x7, x8) = U3(x1, x3, x4, x6, x8)
U4(x1, x2, x3, x4, x5, x6, x7, x8) = U4(x5, x8)
U2(x1, x2, x3, x4, x5, x6) = U2(x1, x2, x3, x6)
halt = halt
turing_out(x1, x2, x3, x4) = turing_out(x2, x4)
U10¹(x1, x2, x3, x4, x5, x6) = U10¹(x3, x6)
U5¹(x1, x2, x3, x4, x5, x6) = U5¹(x1, x4, x6)
TURING_IN(x1, x2, x3, x4) = TURING_IN(x1, x3)
U2¹(x1, x2, x3, x4, x5, x6) = U2¹(x1, x2, x3, x6)
U3¹(x1, x2, x3, x4, x5, x6, x7, x8) = U3¹(x1, x3, x4, x6, x8)
MEMBER_IN(x1, x2) = MEMBER_IN(x2)
U9¹(x1, x2, x3, x4, x5, x6) = U9¹(x2, x4, x6)
U7¹(x1, x2, x3, x4, x5, x6, x7, x8) = U7¹(x1, x2, x4, x6, x8)
U4¹(x1, x2, x3, x4, x5, x6, x7, x8) = U4¹(x5, x8)
U8¹(x1, x2, x3, x4, x5, x6, x7, x8) = U8¹(x5, x8)
U6¹(x1, x2, x3, x4, x5, x6) = U6¹(x3, x6)
U1¹(x1, x2, x3, x4) = U1¹(x4)

We have to consider all (P,R,Pi)-chains

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

  ↳ PrologToPiTRSProof

Pi DP problem:
The TRS P consists of the following rules:

TURING_IN(t([], Y, R), S, P, T) → U9¹(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
TURING_IN(t([], Y, R), S, P, T) → MEMBER_IN(p(S, Y, S1, W, l), P)
MEMBER_IN(X, .(H, L)) → U1¹(X, H, L, member_in(X, L))
MEMBER_IN(X, .(H, L)) → MEMBER_IN(X, L)
U9¹(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U10¹(Y, R, S, P, T, turing_in(t([], space, .(W, R)), S1, P, T))
U9¹(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → TURING_IN(t([], space, .(W, R)), S1, P, T)
TURING_IN(t(.(X, L), Y, R), S, P, T) → U7¹(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
TURING_IN(t(.(X, L), Y, R), S, P, T) → MEMBER_IN(p(S, Y, S1, W, l), P)
U7¹(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U8¹(X, L, Y, R, S, P, T, turing_in(t(L, X, .(W, R)), S1, P, T))
U7¹(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → TURING_IN(t(L, X, .(W, R)), S1, P, T)
TURING_IN(t(X, Y, []), S, P, T) → U5¹(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))
TURING_IN(t(X, Y, []), S, P, T) → MEMBER_IN(p(S, Y, S1, W, r), P)
U5¹(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U6¹(X, Y, S, P, T, turing_in(t(.(W, X), space, []), S1, P, T))
U5¹(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → TURING_IN(t(.(W, X), space, []), S1, P, T)
TURING_IN(t(X, Y, .(R, L)), S, P, T) → U3¹(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
TURING_IN(t(X, Y, .(R, L)), S, P, T) → MEMBER_IN(p(S, Y, S1, W, r), P)
U3¹(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U4¹(X, Y, R, L, S, P, T, turing_in(t(.(W, X), R, L), S1, P, T))
U3¹(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → TURING_IN(t(.(W, X), R, L), S1, P, T)
TURING_IN(t(X, Y, Z), S, P, t(X, Y, Z)) → U2¹(X, Y, Z, S, P, member_in(p(S, Y, halt, W, D), P))
TURING_IN(t(X, Y, Z), S, P, t(X, Y, Z)) → MEMBER_IN(p(S, Y, halt, W, D), P)

The TRS R consists of the following rules:

turing_in(t([], Y, R), S, P, T) → U9(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
member_in(X, .(H, L)) → U1(X, H, L, member_in(X, L))
member_in(H, .(H, L)) → member_out(H, .(H, L))
U1(X, H, L, member_out(X, L)) → member_out(X, .(H, L))
U9(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U10(Y, R, S, P, T, turing_in(t([], space, .(W, R)), S1, P, T))
turing_in(t(.(X, L), Y, R), S, P, T) → U7(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
U7(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U8(X, L, Y, R, S, P, T, turing_in(t(L, X, .(W, R)), S1, P, T))
turing_in(t(X, Y, []), S, P, T) → U5(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))
U5(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U6(X, Y, S, P, T, turing_in(t(.(W, X), space, []), S1, P, T))
turing_in(t(X, Y, .(R, L)), S, P, T) → U3(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
U3(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U4(X, Y, R, L, S, P, T, turing_in(t(.(W, X), R, L), S1, P, T))
turing_in(t(X, Y, Z), S, P, t(X, Y, Z)) → U2(X, Y, Z, S, P, member_in(p(S, Y, halt, W, D), P))
U2(X, Y, Z, S, P, member_out(p(S, Y, halt, W, D), P)) → turing_out(t(X, Y, Z), S, P, t(X, Y, Z))
U4(X, Y, R, L, S, P, T, turing_out(t(.(W, X), R, L), S1, P, T)) → turing_out(t(X, Y, .(R, L)), S, P, T)
U6(X, Y, S, P, T, turing_out(t(.(W, X), space, []), S1, P, T)) → turing_out(t(X, Y, []), S, P, T)
U8(X, L, Y, R, S, P, T, turing_out(t(L, X, .(W, R)), S1, P, T)) → turing_out(t(.(X, L), Y, R), S, P, T)
U10(Y, R, S, P, T, turing_out(t([], space, .(W, R)), S1, P, T)) → turing_out(t([], Y, R), S, P, T)

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

                ↳ UsableRulesProof

              ↳ PiDP

  ↳ PrologToPiTRSProof

Pi DP problem:
The TRS P consists of the following rules:

MEMBER_IN(X, .(H, L)) → MEMBER_IN(X, L)

The TRS R consists of the following rules:

turing_in(t([], Y, R), S, P, T) → U9(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
member_in(X, .(H, L)) → U1(X, H, L, member_in(X, L))
member_in(H, .(H, L)) → member_out(H, .(H, L))
U1(X, H, L, member_out(X, L)) → member_out(X, .(H, L))
U9(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U10(Y, R, S, P, T, turing_in(t([], space, .(W, R)), S1, P, T))
turing_in(t(.(X, L), Y, R), S, P, T) → U7(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
U7(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U8(X, L, Y, R, S, P, T, turing_in(t(L, X, .(W, R)), S1, P, T))
turing_in(t(X, Y, []), S, P, T) → U5(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))
U5(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U6(X, Y, S, P, T, turing_in(t(.(W, X), space, []), S1, P, T))
turing_in(t(X, Y, .(R, L)), S, P, T) → U3(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
U3(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U4(X, Y, R, L, S, P, T, turing_in(t(.(W, X), R, L), S1, P, T))
turing_in(t(X, Y, Z), S, P, t(X, Y, Z)) → U2(X, Y, Z, S, P, member_in(p(S, Y, halt, W, D), P))
U2(X, Y, Z, S, P, member_out(p(S, Y, halt, W, D), P)) → turing_out(t(X, Y, Z), S, P, t(X, Y, Z))
U4(X, Y, R, L, S, P, T, turing_out(t(.(W, X), R, L), S1, P, T)) → turing_out(t(X, Y, .(R, L)), S, P, T)
U6(X, Y, S, P, T, turing_out(t(.(W, X), space, []), S1, P, T)) → turing_out(t(X, Y, []), S, P, T)
U8(X, L, Y, R, S, P, T, turing_out(t(L, X, .(W, R)), S1, P, T)) → turing_out(t(.(X, L), Y, R), S, P, T)
U10(Y, R, S, P, T, turing_out(t([], space, .(W, R)), S1, P, T)) → turing_out(t([], Y, R), S, P, T)

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

              ↳ PiDP

  ↳ PrologToPiTRSProof

Pi DP problem:
The TRS P consists of the following rules:

MEMBER_IN(X, .(H, L)) → MEMBER_IN(X, L)

R is empty.
The argument filtering Pi contains the following mapping:
.(x1, x2) = .(x1, x2)
MEMBER_IN(x1, x2) = MEMBER_IN(x2)

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ PiDP

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

MEMBER_IN(.(H, L)) → MEMBER_IN(L)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

MEMBER_IN(.(H, L)) → MEMBER_IN(L)
The graph contains the following edges 1 > 1

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

  ↳ PrologToPiTRSProof

Pi DP problem:
The TRS P consists of the following rules:

TURING_IN(t([], Y, R), S, P, T) → U9¹(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
U9¹(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → TURING_IN(t([], space, .(W, R)), S1, P, T)
U5¹(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → TURING_IN(t(.(W, X), space, []), S1, P, T)
TURING_IN(t(X, Y, .(R, L)), S, P, T) → U3¹(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
U7¹(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → TURING_IN(t(L, X, .(W, R)), S1, P, T)
U3¹(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → TURING_IN(t(.(W, X), R, L), S1, P, T)
TURING_IN(t(.(X, L), Y, R), S, P, T) → U7¹(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
TURING_IN(t(X, Y, []), S, P, T) → U5¹(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))

The TRS R consists of the following rules:

turing_in(t([], Y, R), S, P, T) → U9(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
member_in(X, .(H, L)) → U1(X, H, L, member_in(X, L))
member_in(H, .(H, L)) → member_out(H, .(H, L))
U1(X, H, L, member_out(X, L)) → member_out(X, .(H, L))
U9(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U10(Y, R, S, P, T, turing_in(t([], space, .(W, R)), S1, P, T))
turing_in(t(.(X, L), Y, R), S, P, T) → U7(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
U7(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U8(X, L, Y, R, S, P, T, turing_in(t(L, X, .(W, R)), S1, P, T))
turing_in(t(X, Y, []), S, P, T) → U5(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))
U5(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U6(X, Y, S, P, T, turing_in(t(.(W, X), space, []), S1, P, T))
turing_in(t(X, Y, .(R, L)), S, P, T) → U3(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
U3(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U4(X, Y, R, L, S, P, T, turing_in(t(.(W, X), R, L), S1, P, T))
turing_in(t(X, Y, Z), S, P, t(X, Y, Z)) → U2(X, Y, Z, S, P, member_in(p(S, Y, halt, W, D), P))
U2(X, Y, Z, S, P, member_out(p(S, Y, halt, W, D), P)) → turing_out(t(X, Y, Z), S, P, t(X, Y, Z))
U4(X, Y, R, L, S, P, T, turing_out(t(.(W, X), R, L), S1, P, T)) → turing_out(t(X, Y, .(R, L)), S, P, T)
U6(X, Y, S, P, T, turing_out(t(.(W, X), space, []), S1, P, T)) → turing_out(t(X, Y, []), S, P, T)
U8(X, L, Y, R, S, P, T, turing_out(t(L, X, .(W, R)), S1, P, T)) → turing_out(t(.(X, L), Y, R), S, P, T)
U10(Y, R, S, P, T, turing_out(t([], space, .(W, R)), S1, P, T)) → turing_out(t([], Y, R), S, P, T)

The argument filtering Pi contains the following mapping:
turing_in(x1, x2, x3, x4) = turing_in(x1, x3)
t(x1, x2, x3) = t(x1, x2, x3)
[] = []
U9(x1, x2, x3, x4, x5, x6) = U9(x2, x4, x6)
member_in(x1, x2) = member_in(x2)
p(x1, x2, x3, x4, x5) = p(x1, x2, x4, x5)
l = l
.(x1, x2) = .(x1, x2)
U1(x1, x2, x3, x4) = U1(x4)
member_out(x1, x2) = member_out(x1)
U10(x1, x2, x3, x4, x5, x6) = U10(x3, x6)
space = space
U7(x1, x2, x3, x4, x5, x6, x7, x8) = U7(x1, x2, x4, x6, x8)
U8(x1, x2, x3, x4, x5, x6, x7, x8) = U8(x5, x8)
U5(x1, x2, x3, x4, x5, x6) = U5(x1, x4, x6)
r = r
U6(x1, x2, x3, x4, x5, x6) = U6(x3, x6)
U3(x1, x2, x3, x4, x5, x6, x7, x8) = U3(x1, x3, x4, x6, x8)
U4(x1, x2, x3, x4, x5, x6, x7, x8) = U4(x5, x8)
U2(x1, x2, x3, x4, x5, x6) = U2(x1, x2, x3, x6)
halt = halt
turing_out(x1, x2, x3, x4) = turing_out(x2, x4)
U5¹(x1, x2, x3, x4, x5, x6) = U5¹(x1, x4, x6)
TURING_IN(x1, x2, x3, x4) = TURING_IN(x1, x3)
U3¹(x1, x2, x3, x4, x5, x6, x7, x8) = U3¹(x1, x3, x4, x6, x8)
U9¹(x1, x2, x3, x4, x5, x6) = U9¹(x2, x4, x6)
U7¹(x1, x2, x3, x4, x5, x6, x7, x8) = U7¹(x1, x2, x4, x6, x8)

We have to consider all (P,R,Pi)-chains
For (infinitary) constructor rewriting [30] we can delete all non-usable rules from R.

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

  ↳ PrologToPiTRSProof

Pi DP problem:
The TRS P consists of the following rules:

TURING_IN(t([], Y, R), S, P, T) → U9¹(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
U9¹(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → TURING_IN(t([], space, .(W, R)), S1, P, T)
U5¹(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → TURING_IN(t(.(W, X), space, []), S1, P, T)
TURING_IN(t(X, Y, .(R, L)), S, P, T) → U3¹(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
U7¹(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → TURING_IN(t(L, X, .(W, R)), S1, P, T)
U3¹(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → TURING_IN(t(.(W, X), R, L), S1, P, T)
TURING_IN(t(.(X, L), Y, R), S, P, T) → U7¹(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
TURING_IN(t(X, Y, []), S, P, T) → U5¹(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))

The TRS R consists of the following rules:

member_in(X, .(H, L)) → U1(X, H, L, member_in(X, L))
member_in(H, .(H, L)) → member_out(H, .(H, L))
U1(X, H, L, member_out(X, L)) → member_out(X, .(H, L))

The argument filtering Pi contains the following mapping:
t(x1, x2, x3) = t(x1, x2, x3)
[] = []
member_in(x1, x2) = member_in(x2)
p(x1, x2, x3, x4, x5) = p(x1, x2, x4, x5)
l = l
.(x1, x2) = .(x1, x2)
U1(x1, x2, x3, x4) = U1(x4)
member_out(x1, x2) = member_out(x1)
space = space
r = r
U5¹(x1, x2, x3, x4, x5, x6) = U5¹(x1, x4, x6)
TURING_IN(x1, x2, x3, x4) = TURING_IN(x1, x3)
U3¹(x1, x2, x3, x4, x5, x6, x7, x8) = U3¹(x1, x3, x4, x6, x8)
U9¹(x1, x2, x3, x4, x5, x6) = U9¹(x2, x4, x6)
U7¹(x1, x2, x3, x4, x5, x6, x7, x8) = U7¹(x1, x2, x4, x6, x8)

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(X, L, R, P, member_out(p(S, Y, W, l))) → TURING_IN(t(L, X, .(W, R)), P)
U5¹(X, P, member_out(p(S, Y, W, r))) → TURING_IN(t(.(W, X), space, []), P)
TURING_IN(t(.(X, L), Y, R), P) → U7¹(X, L, R, P, member_in(P))
U3¹(X, R, L, P, member_out(p(S, Y, W, r))) → TURING_IN(t(.(W, X), R, L), P)
TURING_IN(t([], Y, R), P) → U9¹(R, P, member_in(P))
U9¹(R, P, member_out(p(S, Y, W, l))) → TURING_IN(t([], space, .(W, R)), P)
TURING_IN(t(X, Y, .(R, L)), P) → U3¹(X, R, L, P, member_in(P))
TURING_IN(t(X, Y, []), P) → U5¹(X, P, member_in(P))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule TURING_IN(t([], Y, R), P) → U9¹(R, P, member_in(P)) at position [2] we obtained the following new rules:

TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), member_out(x0))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), U1(member_in(x1)))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(X, L, R, P, member_out(p(S, Y, W, l))) → TURING_IN(t(L, X, .(W, R)), P)
U5¹(X, P, member_out(p(S, Y, W, r))) → TURING_IN(t(.(W, X), space, []), P)
U3¹(X, R, L, P, member_out(p(S, Y, W, r))) → TURING_IN(t(.(W, X), R, L), P)
TURING_IN(t(.(X, L), Y, R), P) → U7¹(X, L, R, P, member_in(P))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), U1(member_in(x1)))
U9¹(R, P, member_out(p(S, Y, W, l))) → TURING_IN(t([], space, .(W, R)), P)
TURING_IN(t(X, Y, .(R, L)), P) → U3¹(X, R, L, P, member_in(P))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), member_out(x0))
TURING_IN(t(X, Y, []), P) → U5¹(X, P, member_in(P))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule TURING_IN(t(X, Y, .(R, L)), P) → U3¹(X, R, L, P, member_in(P)) at position [4] we obtained the following new rules:

TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), member_out(x0))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(X, L, R, P, member_out(p(S, Y, W, l))) → TURING_IN(t(L, X, .(W, R)), P)
U5¹(X, P, member_out(p(S, Y, W, r))) → TURING_IN(t(.(W, X), space, []), P)
TURING_IN(t(.(X, L), Y, R), P) → U7¹(X, L, R, P, member_in(P))
U3¹(X, R, L, P, member_out(p(S, Y, W, r))) → TURING_IN(t(.(W, X), R, L), P)
U9¹(R, P, member_out(p(S, Y, W, l))) → TURING_IN(t([], space, .(W, R)), P)
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(X, Y, []), P) → U5¹(X, P, member_in(P))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), member_out(x0))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), member_out(x0))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule TURING_IN(t(.(X, L), Y, R), P) → U7¹(X, L, R, P, member_in(P)) at position [4] we obtained the following new rules:

TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), member_out(x0))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(X, L, R, P, member_out(p(S, Y, W, l))) → TURING_IN(t(L, X, .(W, R)), P)
U5¹(X, P, member_out(p(S, Y, W, r))) → TURING_IN(t(.(W, X), space, []), P)
U3¹(X, R, L, P, member_out(p(S, Y, W, r))) → TURING_IN(t(.(W, X), R, L), P)
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), U1(member_in(x1)))
U9¹(R, P, member_out(p(S, Y, W, l))) → TURING_IN(t([], space, .(W, R)), P)
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), member_out(x0))
TURING_IN(t(X, Y, []), P) → U5¹(X, P, member_in(P))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), member_out(x0))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), member_out(x0))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule TURING_IN(t(X, Y, []), P) → U5¹(X, P, member_in(P)) at position [2] we obtained the following new rules:

TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), member_out(x0))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), U1(member_in(x1)))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), member_out(x0))
U9¹(R, P, member_out(p(S, Y, W, l))) → TURING_IN(t([], space, .(W, R)), P)
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), member_out(x0))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), member_out(x0))
U7¹(X, L, R, P, member_out(p(S, Y, W, l))) → TURING_IN(t(L, X, .(W, R)), P)
U5¹(X, P, member_out(p(S, Y, W, r))) → TURING_IN(t(.(W, X), space, []), P)
U3¹(X, R, L, P, member_out(p(S, Y, W, r))) → TURING_IN(t(.(W, X), R, L), P)
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), member_out(x0))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U9¹(R, P, member_out(p(S, Y, W, l))) → TURING_IN(t([], space, .(W, R)), P) we obtained the following new rules:

U9¹(z1, .(p(x2, x3, x4, l), z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(p(x2, x3, x4, l), z3))
U9¹(z1, .(z2, z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), member_out(x0))
U9¹(z1, .(p(x2, x3, x4, l), z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(p(x2, x3, x4, l), z3))
U9¹(z1, .(z2, z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), member_out(x0))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), member_out(x0))
U7¹(X, L, R, P, member_out(p(S, Y, W, l))) → TURING_IN(t(L, X, .(W, R)), P)
U5¹(X, P, member_out(p(S, Y, W, r))) → TURING_IN(t(.(W, X), space, []), P)
U3¹(X, R, L, P, member_out(p(S, Y, W, r))) → TURING_IN(t(.(W, X), R, L), P)
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), member_out(x0))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U5¹(X, P, member_out(p(S, Y, W, r))) → TURING_IN(t(.(W, X), space, []), P) we obtained the following new rules:

U5¹(z0, .(z2, z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))
U5¹(z0, .(p(x2, x3, x4, r), z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(p(x2, x3, x4, r), z3))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), member_out(x0))
U9¹(z1, .(p(x2, x3, x4, l), z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(p(x2, x3, x4, l), z3))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
U9¹(z1, .(z2, z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), member_out(x0))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), member_out(x0))
U5¹(z0, .(z2, z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))
U7¹(X, L, R, P, member_out(p(S, Y, W, l))) → TURING_IN(t(L, X, .(W, R)), P)
U5¹(z0, .(p(x2, x3, x4, r), z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(p(x2, x3, x4, r), z3))
U3¹(X, R, L, P, member_out(p(S, Y, W, r))) → TURING_IN(t(.(W, X), R, L), P)
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), member_out(x0))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U7¹(X, L, R, P, member_out(p(S, Y, W, l))) → TURING_IN(t(L, X, .(W, R)), P) we obtained the following new rules:

U7¹(z0, z1, z3, .(z4, z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
U7¹(z0, z1, z3, .(p(x4, x5, x6, l), z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x4, x5, x6, l), z5))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(z0, z1, z3, .(z4, z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), member_out(x0))
U9¹(z1, .(p(x2, x3, x4, l), z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(p(x2, x3, x4, l), z3))
U9¹(z1, .(z2, z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), member_out(x0))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), member_out(x0))
U5¹(z0, .(z2, z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))
U7¹(z0, z1, z3, .(p(x4, x5, x6, l), z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x4, x5, x6, l), z5))
U5¹(z0, .(p(x2, x3, x4, r), z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(p(x2, x3, x4, r), z3))
U3¹(X, R, L, P, member_out(p(S, Y, W, r))) → TURING_IN(t(.(W, X), R, L), P)
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), member_out(x0))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U3¹(X, R, L, P, member_out(p(S, Y, W, r))) → TURING_IN(t(.(W, X), R, L), P) we obtained the following new rules:

U3¹(z0, z2, z3, .(p(x4, x5, x6, r), z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x4, x5, x6, r), z5))
U3¹(z0, z2, z3, .(z4, z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(z0, z1, z3, .(z4, z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), member_out(x0))
U9¹(z1, .(p(x2, x3, x4, l), z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(p(x2, x3, x4, l), z3))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
U9¹(z1, .(z2, z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), member_out(x0))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), member_out(x0))
U3¹(z0, z2, z3, .(p(x4, x5, x6, r), z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x4, x5, x6, r), z5))
U5¹(z0, .(z2, z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))
U7¹(z0, z1, z3, .(p(x4, x5, x6, l), z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x4, x5, x6, l), z5))
U5¹(z0, .(p(x2, x3, x4, r), z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(p(x2, x3, x4, r), z3))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), member_out(x0))
U3¹(z0, z2, z3, .(z4, z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), member_out(x0)) we obtained the following new rules:

TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), member_out(p(z3, z4, z5, l)))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), member_out(z3))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), member_out(z1))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), member_out(p(z1, z2, z3, l)))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), member_out(p(z3, z4, z5, l)))
U7¹(z0, z1, z3, .(z4, z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), member_out(x0))
U9¹(z1, .(p(x2, x3, x4, l), z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(p(x2, x3, x4, l), z3))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), member_out(z1))
U9¹(z1, .(z2, z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), member_out(x0))
U3¹(z0, z2, z3, .(p(x4, x5, x6, r), z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x4, x5, x6, r), z5))
U5¹(z0, .(z2, z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))
U7¹(z0, z1, z3, .(p(x4, x5, x6, l), z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x4, x5, x6, l), z5))
U5¹(z0, .(p(x2, x3, x4, r), z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(p(x2, x3, x4, r), z3))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), member_out(z3))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), member_out(x0))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), member_out(p(z1, z2, z3, l)))
U3¹(z0, z2, z3, .(z4, z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y1, .(x0, x1), U1(member_in(x1))) we obtained the following new rules:

TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), U1(member_in(z6)))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), U1(member_in(z4)))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), U1(member_in(z4)))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(z0, z1, z3, .(z4, z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), member_out(p(z3, z4, z5, l)))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), member_out(x0))
U9¹(z1, .(p(x2, x3, x4, l), z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(p(x2, x3, x4, l), z3))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), U1(member_in(z6)))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), member_out(z1))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
U9¹(z1, .(z2, z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), member_out(x0))
U3¹(z0, z2, z3, .(p(x4, x5, x6, r), z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x4, x5, x6, r), z5))
U5¹(z0, .(z2, z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))
U7¹(z0, z1, z3, .(p(x4, x5, x6, l), z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x4, x5, x6, l), z5))
U5¹(z0, .(p(x2, x3, x4, r), z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(p(x2, x3, x4, r), z3))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), member_out(z3))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), U1(member_in(z4)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), member_out(x0))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), U1(member_in(z4)))
U3¹(z0, z2, z3, .(z4, z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), member_out(p(z1, z2, z3, l)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), member_out(x0)) we obtained the following new rules:

TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), member_out(z3))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), member_out(p(z3, z4, z5, r)))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), member_out(z1))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), member_out(p(z1, z2, z3, r)))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(z0, z1, z3, .(z4, z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), member_out(z1))
U9¹(z1, .(z2, z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), member_out(p(z1, z2, z3, r)))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), member_out(x0))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), member_out(z3))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), member_out(x0))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), member_out(p(z3, z4, z5, l)))
U9¹(z1, .(p(x2, x3, x4, l), z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(p(x2, x3, x4, l), z3))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), member_out(p(z3, z4, z5, r)))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), member_out(z1))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), U1(member_in(z6)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
U3¹(z0, z2, z3, .(p(x4, x5, x6, r), z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x4, x5, x6, r), z5))
U5¹(z0, .(z2, z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))
U7¹(z0, z1, z3, .(p(x4, x5, x6, l), z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x4, x5, x6, l), z5))
U5¹(z0, .(p(x2, x3, x4, r), z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(p(x2, x3, x4, r), z3))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), member_out(z3))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), U1(member_in(z4)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), U1(member_in(z4)))
U3¹(z0, z2, z3, .(z4, z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), member_out(p(z1, z2, z3, l)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, .(x0, x1), U1(member_in(x1))) we obtained the following new rules:

TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), U1(member_in(z6)))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), U1(member_in(z4)))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), U1(member_in(z4)))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(z0, z1, z3, .(z4, z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), member_out(z1))
U9¹(z1, .(z2, z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), member_out(p(z1, z2, z3, r)))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), member_out(x0))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), U1(member_in(z4)))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), member_out(z3))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), member_out(x0))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), U1(member_in(z4)))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), member_out(p(z3, z4, z5, l)))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), member_out(p(z3, z4, z5, r)))
U9¹(z1, .(p(x2, x3, x4, l), z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(p(x2, x3, x4, l), z3))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), member_out(z1))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), U1(member_in(z6)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
U3¹(z0, z2, z3, .(p(x4, x5, x6, r), z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x4, x5, x6, r), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), U1(member_in(z6)))
U5¹(z0, .(z2, z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))
U7¹(z0, z1, z3, .(p(x4, x5, x6, l), z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x4, x5, x6, l), z5))
U5¹(z0, .(p(x2, x3, x4, r), z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(p(x2, x3, x4, r), z3))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), member_out(z3))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), U1(member_in(z4)))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), member_out(p(z1, z2, z3, l)))
U3¹(z0, z2, z3, .(z4, z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), U1(member_in(z4)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U9¹(z1, .(p(x2, x3, x4, l), z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(p(x2, x3, x4, l), z3)) we obtained the following new rules:

U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(z3, z4, z1, l))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z4, z1, l), z5))
U9¹(.(z1, z2), .(p(x1, x2, x3, l), z4), member_out(p(x1, x2, x3, l))) → TURING_IN(t([], space, .(x3, .(z1, z2))), .(p(x1, x2, x3, l), z4))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(z0, z1, z3, .(z4, z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), member_out(z1))
U9¹(z1, .(z2, z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), member_out(p(z1, z2, z3, r)))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), member_out(x0))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), U1(member_in(z4)))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), member_out(z3))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), member_out(x0))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), member_out(p(z3, z4, z5, l)))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), U1(member_in(z4)))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(z3, z4, z1, l))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), member_out(p(z3, z4, z5, r)))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), member_out(z1))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), U1(member_in(z6)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
U3¹(z0, z2, z3, .(p(x4, x5, x6, r), z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x4, x5, x6, r), z5))
U5¹(z0, .(z2, z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), U1(member_in(z6)))
U7¹(z0, z1, z3, .(p(x4, x5, x6, l), z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x4, x5, x6, l), z5))
U5¹(z0, .(p(x2, x3, x4, r), z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(p(x2, x3, x4, r), z3))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), member_out(z3))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), U1(member_in(z4)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
U9¹(.(z1, z2), .(p(x1, x2, x3, l), z4), member_out(p(x1, x2, x3, l))) → TURING_IN(t([], space, .(x3, .(z1, z2))), .(p(x1, x2, x3, l), z4))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), U1(member_in(z4)))
U3¹(z0, z2, z3, .(z4, z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), member_out(p(z1, z2, z3, l)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U9¹(z1, .(z2, z3), member_out(p(x2, x3, x4, l))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3)) we obtained the following new rules:

U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(z3, z4, z1, l))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z4, z1, l), z5))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
U9¹(.(z1, z2), .(z3, z4), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
U9¹(.(z1, z2), .(p(x3, x4, x5, l), z4), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(x3, x4, x5, l), z4))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

                                                                              ↳ QDP

                                                                                ↳ Instantiation

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(z0, z1, z3, .(z4, z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), member_out(z1))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), member_out(p(z1, z2, z3, r)))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), member_out(x0))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), U1(member_in(z4)))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), member_out(z3))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), member_out(x0))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), U1(member_in(z4)))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), member_out(p(z3, z4, z5, l)))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(z3, z4, z1, l))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), member_out(p(z3, z4, z5, r)))
U9¹(.(z1, z2), .(z3, z4), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), member_out(z1))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), U1(member_in(z6)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
U3¹(z0, z2, z3, .(p(x4, x5, x6, r), z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x4, x5, x6, r), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), U1(member_in(z6)))
U5¹(z0, .(z2, z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))
U7¹(z0, z1, z3, .(p(x4, x5, x6, l), z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x4, x5, x6, l), z5))
U5¹(z0, .(p(x2, x3, x4, r), z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(p(x2, x3, x4, r), z3))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), member_out(z3))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), U1(member_in(z4)))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
U9¹(.(z1, z2), .(p(x1, x2, x3, l), z4), member_out(p(x1, x2, x3, l))) → TURING_IN(t([], space, .(x3, .(z1, z2))), .(p(x1, x2, x3, l), z4))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), member_out(p(z1, z2, z3, l)))
U3¹(z0, z2, z3, .(z4, z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), U1(member_in(z4)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U5¹(z0, .(z2, z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3)) we obtained the following new rules:

U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(z3, z4, z0, r))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
U5¹(.(z0, z1), .(p(x3, x4, x5, r), z4), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(x3, x4, x5, r), z4))
U5¹(.(z0, z1), .(z2, z3), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z2, z3))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Instantiation

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(z0, z1, z3, .(z4, z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), member_out(z1))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), member_out(p(z1, z2, z3, r)))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), member_out(x0))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), U1(member_in(z4)))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), member_out(z3))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), member_out(x0))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), member_out(p(z3, z4, z5, l)))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), U1(member_in(z4)))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(z3, z4, z1, l))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), member_out(p(z3, z4, z5, r)))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), member_out(z1))
U9¹(.(z1, z2), .(z3, z4), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), U1(member_in(z6)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
U3¹(z0, z2, z3, .(p(x4, x5, x6, r), z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x4, x5, x6, r), z5))
U5¹(.(z0, z1), .(p(x3, x4, x5, r), z4), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(x3, x4, x5, r), z4))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(z3, z4, z0, r))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), U1(member_in(z6)))
U7¹(z0, z1, z3, .(p(x4, x5, x6, l), z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x4, x5, x6, l), z5))
U5¹(z0, .(p(x2, x3, x4, r), z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(p(x2, x3, x4, r), z3))
U5¹(.(z0, z1), .(z2, z3), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z2, z3))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), member_out(z3))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), U1(member_in(z4)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
U9¹(.(z1, z2), .(p(x1, x2, x3, l), z4), member_out(p(x1, x2, x3, l))) → TURING_IN(t([], space, .(x3, .(z1, z2))), .(p(x1, x2, x3, l), z4))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), U1(member_in(z4)))
U3¹(z0, z2, z3, .(z4, z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), member_out(p(z1, z2, z3, l)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U5¹(z0, .(p(x2, x3, x4, r), z3), member_out(p(x2, x3, x4, r))) → TURING_IN(t(.(x4, z0), space, []), .(p(x2, x3, x4, r), z3)) we obtained the following new rules:

U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(z3, z4, z0, r))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
U5¹(.(z0, z1), .(p(x1, x2, x3, r), z4), member_out(p(x1, x2, x3, r))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x1, x2, x3, r), z4))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Instantiation

                                                                                      ↳ QDP

                                                                                        ↳ ForwardInstantiation

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(z0, z1, z3, .(z4, z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), member_out(z1))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), member_out(p(z1, z2, z3, r)))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), member_out(x0))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), U1(member_in(z4)))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), member_out(z3))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), member_out(x0))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), U1(member_in(z4)))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), member_out(p(z3, z4, z5, l)))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(z3, z4, z1, l))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), member_out(p(z3, z4, z5, r)))
U9¹(.(z1, z2), .(z3, z4), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), member_out(z1))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), U1(member_in(z6)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
U3¹(z0, z2, z3, .(p(x4, x5, x6, r), z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x4, x5, x6, r), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), U1(member_in(z6)))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(z3, z4, z0, r))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
U5¹(.(z0, z1), .(p(x3, x4, x5, r), z4), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(x3, x4, x5, r), z4))
U7¹(z0, z1, z3, .(p(x4, x5, x6, l), z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x4, x5, x6, l), z5))
U5¹(.(z0, z1), .(z2, z3), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z2, z3))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), member_out(z3))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), U1(member_in(z4)))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
U9¹(.(z1, z2), .(p(x1, x2, x3, l), z4), member_out(p(x1, x2, x3, l))) → TURING_IN(t([], space, .(x3, .(z1, z2))), .(p(x1, x2, x3, l), z4))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), member_out(p(z1, z2, z3, l)))
U3¹(z0, z2, z3, .(z4, z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), U1(member_in(z4)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), member_out(x0)) we obtained the following new rules:

TURING_IN(t(x0, x1, .(x2, x3)), .(p(y_3, y_4, y_5, r), x5)) → U3¹(x0, x2, x3, .(p(y_3, y_4, y_5, r), x5), member_out(p(y_3, y_4, y_5, r)))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Instantiation

                                                                                      ↳ QDP

                                                                                        ↳ ForwardInstantiation

                                                                                          ↳ QDP

                                                                                            ↳ ForwardInstantiation

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(z0, z1, z3, .(z4, z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), member_out(z1))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), member_out(p(z1, z2, z3, r)))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), U1(member_in(z4)))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), member_out(z3))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(x0, x1, .(x2, x3)), .(p(y_3, y_4, y_5, r), x5)) → U3¹(x0, x2, x3, .(p(y_3, y_4, y_5, r), x5), member_out(p(y_3, y_4, y_5, r)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), member_out(x0))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), member_out(p(z3, z4, z5, l)))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), U1(member_in(z4)))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(z3, z4, z1, l))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), member_out(p(z3, z4, z5, r)))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), member_out(z1))
U9¹(.(z1, z2), .(z3, z4), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), U1(member_in(z6)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
U3¹(z0, z2, z3, .(p(x4, x5, x6, r), z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x4, x5, x6, r), z5))
U5¹(.(z0, z1), .(p(x3, x4, x5, r), z4), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(x3, x4, x5, r), z4))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(z3, z4, z0, r))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), U1(member_in(z6)))
U7¹(z0, z1, z3, .(p(x4, x5, x6, l), z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x4, x5, x6, l), z5))
U5¹(.(z0, z1), .(z2, z3), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z2, z3))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), member_out(z3))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), U1(member_in(z4)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
U9¹(.(z1, z2), .(p(x1, x2, x3, l), z4), member_out(p(x1, x2, x3, l))) → TURING_IN(t([], space, .(x3, .(z1, z2))), .(p(x1, x2, x3, l), z4))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), U1(member_in(z4)))
U3¹(z0, z2, z3, .(z4, z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), member_out(p(z1, z2, z3, l)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), member_out(x0)) we obtained the following new rules:

TURING_IN(t(.(x0, x1), x2, x3), .(p(y_5, y_6, y_7, l), x5)) → U7¹(x0, x1, x3, .(p(y_5, y_6, y_7, l), x5), member_out(p(y_5, y_6, y_7, l)))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Instantiation

                                                                                      ↳ QDP

                                                                                        ↳ ForwardInstantiation

                                                                                          ↳ QDP

                                                                                            ↳ ForwardInstantiation

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(z0, z1, z3, .(z4, z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), member_out(z1))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), member_out(p(z1, z2, z3, r)))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), U1(member_in(z4)))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), member_out(z3))
TURING_IN(t(x0, x1, .(x2, x3)), .(p(y_3, y_4, y_5, r), x5)) → U3¹(x0, x2, x3, .(p(y_3, y_4, y_5, r), x5), member_out(p(y_3, y_4, y_5, r)))
TURING_IN(t(.(x0, x1), x2, x3), .(p(y_5, y_6, y_7, l), x5)) → U7¹(x0, x1, x3, .(p(y_5, y_6, y_7, l), x5), member_out(p(y_5, y_6, y_7, l)))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), U1(member_in(z4)))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), member_out(p(z3, z4, z5, l)))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(z3, z4, z1, l))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), member_out(p(z3, z4, z5, r)))
U9¹(.(z1, z2), .(z3, z4), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), member_out(z1))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), U1(member_in(z6)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
U3¹(z0, z2, z3, .(p(x4, x5, x6, r), z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x4, x5, x6, r), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), U1(member_in(z6)))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(z3, z4, z0, r))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
U5¹(.(z0, z1), .(p(x3, x4, x5, r), z4), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(x3, x4, x5, r), z4))
U7¹(z0, z1, z3, .(p(x4, x5, x6, l), z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x4, x5, x6, l), z5))
U5¹(.(z0, z1), .(z2, z3), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z2, z3))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), member_out(z3))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), U1(member_in(z4)))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
U9¹(.(z1, z2), .(p(x1, x2, x3, l), z4), member_out(p(x1, x2, x3, l))) → TURING_IN(t([], space, .(x3, .(z1, z2))), .(p(x1, x2, x3, l), z4))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), member_out(p(z1, z2, z3, l)))
U3¹(z0, z2, z3, .(z4, z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), U1(member_in(z4)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), member_out(z3)) we obtained the following new rules:

TURING_IN(t([], x0, .(x1, x2)), .(p(y_2, y_3, y_4, l), x4)) → U9¹(.(x1, x2), .(p(y_2, y_3, y_4, l), x4), member_out(p(y_2, y_3, y_4, l)))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Instantiation

                                                                                      ↳ QDP

                                                                                        ↳ ForwardInstantiation

                                                                                          ↳ QDP

                                                                                            ↳ ForwardInstantiation

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(z0, z1, z3, .(z4, z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), member_out(z1))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), member_out(p(z1, z2, z3, r)))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), U1(member_in(z4)))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), member_out(z3))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(x0, x1, .(x2, x3)), .(p(y_3, y_4, y_5, r), x5)) → U3¹(x0, x2, x3, .(p(y_3, y_4, y_5, r), x5), member_out(p(y_3, y_4, y_5, r)))
TURING_IN(t(.(x0, x1), x2, x3), .(p(y_5, y_6, y_7, l), x5)) → U7¹(x0, x1, x3, .(p(y_5, y_6, y_7, l), x5), member_out(p(y_5, y_6, y_7, l)))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), member_out(p(z3, z4, z5, l)))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), U1(member_in(z4)))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(z3, z4, z1, l))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), member_out(p(z3, z4, z5, r)))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), member_out(z1))
U9¹(.(z1, z2), .(z3, z4), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), U1(member_in(z6)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
U3¹(z0, z2, z3, .(p(x4, x5, x6, r), z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x4, x5, x6, r), z5))
U5¹(.(z0, z1), .(p(x3, x4, x5, r), z4), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(x3, x4, x5, r), z4))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(z3, z4, z0, r))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), U1(member_in(z6)))
U7¹(z0, z1, z3, .(p(x4, x5, x6, l), z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x4, x5, x6, l), z5))
U5¹(.(z0, z1), .(z2, z3), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z2, z3))
TURING_IN(t([], x0, .(x1, x2)), .(p(y_2, y_3, y_4, l), x4)) → U9¹(.(x1, x2), .(p(y_2, y_3, y_4, l), x4), member_out(p(y_2, y_3, y_4, l)))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), U1(member_in(z4)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
U9¹(.(z1, z2), .(p(x1, x2, x3, l), z4), member_out(p(x1, x2, x3, l))) → TURING_IN(t([], space, .(x3, .(z1, z2))), .(p(x1, x2, x3, l), z4))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), U1(member_in(z4)))
U3¹(z0, z2, z3, .(z4, z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), member_out(p(z1, z2, z3, l)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), member_out(z1)) we obtained the following new rules:

TURING_IN(t([], space, .(x0, x1)), .(p(y_2, y_3, y_4, l), x3)) → U9¹(.(x0, x1), .(p(y_2, y_3, y_4, l), x3), member_out(p(y_2, y_3, y_4, l)))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Instantiation

                                                                                      ↳ QDP

                                                                                        ↳ ForwardInstantiation

                                                                                          ↳ QDP

                                                                                            ↳ ForwardInstantiation

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ ForwardInstantiation

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(z0, z1, z3, .(z4, z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), member_out(p(z1, z2, z3, r)))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), U1(member_in(z4)))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), member_out(z3))
TURING_IN(t(x0, x1, .(x2, x3)), .(p(y_3, y_4, y_5, r), x5)) → U3¹(x0, x2, x3, .(p(y_3, y_4, y_5, r), x5), member_out(p(y_3, y_4, y_5, r)))
TURING_IN(t(.(x0, x1), x2, x3), .(p(y_5, y_6, y_7, l), x5)) → U7¹(x0, x1, x3, .(p(y_5, y_6, y_7, l), x5), member_out(p(y_5, y_6, y_7, l)))
TURING_IN(t([], space, .(x0, x1)), .(p(y_2, y_3, y_4, l), x3)) → U9¹(.(x0, x1), .(p(y_2, y_3, y_4, l), x3), member_out(p(y_2, y_3, y_4, l)))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), U1(member_in(z4)))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), member_out(p(z3, z4, z5, l)))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(z3, z4, z1, l))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), member_out(p(z3, z4, z5, r)))
U9¹(.(z1, z2), .(z3, z4), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), member_out(z1))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), U1(member_in(z6)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
U3¹(z0, z2, z3, .(p(x4, x5, x6, r), z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x4, x5, x6, r), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), U1(member_in(z6)))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(z3, z4, z0, r))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
U5¹(.(z0, z1), .(p(x3, x4, x5, r), z4), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(x3, x4, x5, r), z4))
U7¹(z0, z1, z3, .(p(x4, x5, x6, l), z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x4, x5, x6, l), z5))
U5¹(.(z0, z1), .(z2, z3), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z2, z3))
TURING_IN(t([], x0, .(x1, x2)), .(p(y_2, y_3, y_4, l), x4)) → U9¹(.(x1, x2), .(p(y_2, y_3, y_4, l), x4), member_out(p(y_2, y_3, y_4, l)))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), U1(member_in(z4)))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
U9¹(.(z1, z2), .(p(x1, x2, x3, l), z4), member_out(p(x1, x2, x3, l))) → TURING_IN(t([], space, .(x3, .(z1, z2))), .(p(x1, x2, x3, l), z4))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), member_out(p(z1, z2, z3, l)))
U3¹(z0, z2, z3, .(z4, z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), U1(member_in(z4)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), member_out(z3)) we obtained the following new rules:

TURING_IN(t(.(x0, x1), x2, []), .(p(y_2, y_3, y_4, r), x4)) → U5¹(.(x0, x1), .(p(y_2, y_3, y_4, r), x4), member_out(p(y_2, y_3, y_4, r)))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Instantiation

                                                                                      ↳ QDP

                                                                                        ↳ ForwardInstantiation

                                                                                          ↳ QDP

                                                                                            ↳ ForwardInstantiation

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ ForwardInstantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(z0, z1, z3, .(z4, z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), member_out(p(z1, z2, z3, r)))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), U1(member_in(z4)))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(x0, x1, .(x2, x3)), .(p(y_3, y_4, y_5, r), x5)) → U3¹(x0, x2, x3, .(p(y_3, y_4, y_5, r), x5), member_out(p(y_3, y_4, y_5, r)))
TURING_IN(t(.(x0, x1), x2, x3), .(p(y_5, y_6, y_7, l), x5)) → U7¹(x0, x1, x3, .(p(y_5, y_6, y_7, l), x5), member_out(p(y_5, y_6, y_7, l)))
TURING_IN(t([], space, .(x0, x1)), .(p(y_2, y_3, y_4, l), x3)) → U9¹(.(x0, x1), .(p(y_2, y_3, y_4, l), x3), member_out(p(y_2, y_3, y_4, l)))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), member_out(p(z3, z4, z5, l)))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), U1(member_in(z4)))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(z3, z4, z1, l))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), member_out(p(z3, z4, z5, r)))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), member_out(z1))
U9¹(.(z1, z2), .(z3, z4), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), U1(member_in(z6)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
U3¹(z0, z2, z3, .(p(x4, x5, x6, r), z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x4, x5, x6, r), z5))
U5¹(.(z0, z1), .(p(x3, x4, x5, r), z4), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(x3, x4, x5, r), z4))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(z3, z4, z0, r))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), U1(member_in(z6)))
U7¹(z0, z1, z3, .(p(x4, x5, x6, l), z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x4, x5, x6, l), z5))
U5¹(.(z0, z1), .(z2, z3), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z2, z3))
TURING_IN(t([], x0, .(x1, x2)), .(p(y_2, y_3, y_4, l), x4)) → U9¹(.(x1, x2), .(p(y_2, y_3, y_4, l), x4), member_out(p(y_2, y_3, y_4, l)))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), U1(member_in(z4)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(.(x0, x1), x2, []), .(p(y_2, y_3, y_4, r), x4)) → U5¹(.(x0, x1), .(p(y_2, y_3, y_4, r), x4), member_out(p(y_2, y_3, y_4, r)))
U9¹(.(z1, z2), .(p(x1, x2, x3, l), z4), member_out(p(x1, x2, x3, l))) → TURING_IN(t([], space, .(x3, .(z1, z2))), .(p(x1, x2, x3, l), z4))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), U1(member_in(z4)))
U3¹(z0, z2, z3, .(z4, z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), member_out(p(z1, z2, z3, l)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), member_out(z1)) we obtained the following new rules:

TURING_IN(t(.(x0, x1), space, []), .(p(y_2, y_3, y_4, r), x3)) → U5¹(.(x0, x1), .(p(y_2, y_3, y_4, r), x3), member_out(p(y_2, y_3, y_4, r)))

↳ Prolog

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Instantiation

                                                                                      ↳ QDP

                                                                                        ↳ ForwardInstantiation

                                                                                          ↳ QDP

                                                                                            ↳ ForwardInstantiation

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ ForwardInstantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ NonTerminationProof

  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U7¹(z0, z1, z3, .(z4, z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), member_out(p(z1, z2, z3, r)))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(.(x0, x1), space, []), .(p(y_2, y_3, y_4, r), x3)) → U5¹(.(x0, x1), .(p(y_2, y_3, y_4, r), x3), member_out(p(y_2, y_3, y_4, r)))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), U1(member_in(z4)))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(x0, x1, .(x2, x3)), .(p(y_3, y_4, y_5, r), x5)) → U3¹(x0, x2, x3, .(p(y_3, y_4, y_5, r), x5), member_out(p(y_3, y_4, y_5, r)))
TURING_IN(t(.(x0, x1), x2, x3), .(p(y_5, y_6, y_7, l), x5)) → U7¹(x0, x1, x3, .(p(y_5, y_6, y_7, l), x5), member_out(p(y_5, y_6, y_7, l)))
TURING_IN(t([], space, .(x0, x1)), .(p(y_2, y_3, y_4, l), x3)) → U9¹(.(x0, x1), .(p(y_2, y_3, y_4, l), x3), member_out(p(y_2, y_3, y_4, l)))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), U1(member_in(z4)))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), member_out(p(z3, z4, z5, l)))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(z3, z4, z1, l))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), member_out(p(z3, z4, z5, r)))
U9¹(.(z1, z2), .(z3, z4), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), U1(member_in(z6)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
U3¹(z0, z2, z3, .(p(x4, x5, x6, r), z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x4, x5, x6, r), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), U1(member_in(z6)))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(z3, z4, z0, r))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
U5¹(.(z0, z1), .(p(x3, x4, x5, r), z4), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(x3, x4, x5, r), z4))
U7¹(z0, z1, z3, .(p(x4, x5, x6, l), z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x4, x5, x6, l), z5))
U5¹(.(z0, z1), .(z2, z3), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z2, z3))
TURING_IN(t([], x0, .(x1, x2)), .(p(y_2, y_3, y_4, l), x4)) → U9¹(.(x1, x2), .(p(y_2, y_3, y_4, l), x4), member_out(p(y_2, y_3, y_4, l)))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), U1(member_in(z4)))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(.(x0, x1), x2, []), .(p(y_2, y_3, y_4, r), x4)) → U5¹(.(x0, x1), .(p(y_2, y_3, y_4, r), x4), member_out(p(y_2, y_3, y_4, r)))
U9¹(.(z1, z2), .(p(x1, x2, x3, l), z4), member_out(p(x1, x2, x3, l))) → TURING_IN(t([], space, .(x3, .(z1, z2))), .(p(x1, x2, x3, l), z4))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), member_out(p(z1, z2, z3, l)))
U3¹(z0, z2, z3, .(z4, z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), U1(member_in(z4)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

The set Q consists of the following terms:

member_in(x0)
U1(x0)

We have to consider all (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by narrowing to the left:

The TRS P consists of the following rules:

U7¹(z0, z1, z3, .(z4, z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), member_out(p(z1, z2, z3, r)))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
TURING_IN(t(.(z5, z0), space, []), .(z1, z2)) → U5¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(.(x0, x1), space, []), .(p(y_2, y_3, y_4, r), x3)) → U5¹(.(x0, x1), .(p(y_2, y_3, y_4, r), x3), member_out(p(y_2, y_3, y_4, r)))
TURING_IN(t(.(z7, z0), z1, []), .(z3, z4)) → U5¹(.(z7, z0), .(z3, z4), U1(member_in(z4)))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(x0, x1, .(x2, x3)), .(p(y_3, y_4, y_5, r), x5)) → U3¹(x0, x2, x3, .(p(y_3, y_4, y_5, r), x5), member_out(p(y_3, y_4, y_5, r)))
TURING_IN(t(.(x0, x1), x2, x3), .(p(y_5, y_6, y_7, l), x5)) → U7¹(x0, x1, x3, .(p(y_5, y_6, y_7, l), x5), member_out(p(y_5, y_6, y_7, l)))
TURING_IN(t([], space, .(x0, x1)), .(p(y_2, y_3, y_4, l), x3)) → U9¹(.(x0, x1), .(p(y_2, y_3, y_4, l), x3), member_out(p(y_2, y_3, y_4, l)))
TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), U1(member_in(z4)))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), member_out(p(z3, z4, z5, l)))
U9¹(.(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(z3, z4, z1, l))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), member_out(p(z3, z4, z5, r)))
U9¹(.(z1, z2), .(z3, z4), member_out(p(x3, x4, x5, l))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
TURING_IN(t([], z0, .(z5, z2)), .(p(z3, z4, z5, l), z6)) → U9¹(.(z5, z2), .(p(z3, z4, z5, l), z6), U1(member_in(z6)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y3, .(x0, x1), U1(member_in(x1)))
U3¹(z0, z2, z3, .(p(x4, x5, x6, r), z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x4, x5, x6, r), z5))
TURING_IN(t(.(z5, z0), z1, []), .(p(z3, z4, z5, r), z6)) → U5¹(.(z5, z0), .(p(z3, z4, z5, r), z6), U1(member_in(z6)))
U5¹(.(z0, z1), .(p(z3, z4, z0, r), z5), member_out(p(z3, z4, z0, r))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
U5¹(.(z0, z1), .(p(x3, x4, x5, r), z4), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(x3, x4, x5, r), z4))
U7¹(z0, z1, z3, .(p(x4, x5, x6, l), z5), member_out(p(x4, x5, x6, l))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x4, x5, x6, l), z5))
U5¹(.(z0, z1), .(z2, z3), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z2, z3))
TURING_IN(t([], x0, .(x1, x2)), .(p(y_2, y_3, y_4, l), x4)) → U9¹(.(x1, x2), .(p(y_2, y_3, y_4, l), x4), member_out(p(y_2, y_3, y_4, l)))
TURING_IN(t([], z0, .(z7, z2)), .(z3, z4)) → U9¹(.(z7, z2), .(z3, z4), U1(member_in(z4)))
TURING_IN(t([], space, .(z5, z0)), .(z1, z2)) → U9¹(.(z5, z0), .(z1, z2), U1(member_in(z2)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y2, y3, .(x0, x1), U1(member_in(x1)))
TURING_IN(t(.(x0, x1), x2, []), .(p(y_2, y_3, y_4, r), x4)) → U5¹(.(x0, x1), .(p(y_2, y_3, y_4, r), x4), member_out(p(y_2, y_3, y_4, r)))
U9¹(.(z1, z2), .(p(x1, x2, x3, l), z4), member_out(p(x1, x2, x3, l))) → TURING_IN(t([], space, .(x3, .(z1, z2))), .(p(x1, x2, x3, l), z4))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), member_out(p(z1, z2, z3, l)))
U3¹(z0, z2, z3, .(z4, z5), member_out(p(x4, x5, x6, r))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
TURING_IN(t([], space, .(z3, z0)), .(p(z1, z2, z3, l), z4)) → U9¹(.(z3, z0), .(p(z1, z2, z3, l), z4), U1(member_in(z4)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(member_in(L))
member_in(.(H, L)) → member_out(H)
U1(member_out(X)) → member_out(X)

s = U5¹(.(x5, z1'), .(p(z3', z4', x5, r), z5), member_out(p(x3, x4, x5, r))) evaluates to t =U5¹(.(x5, .(x5, z1')), .(p(z3', z4', x5, r), z5), member_out(p(z3', z4', x5, r)))

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:

Matcher: [x4 / z4', z1' / .(x5, z1'), x3 / z3']
Semiunifier: [ ]

Rewriting sequence

U5¹(.(x5, z1'), .(p(z3', z4', x5, r), z5), member_out(p(x3, x4, x5, r))) → TURING_IN(t(.(x5, .(x5, z1')), space, []), .(p(z3', z4', x5, r), z5))
with rule U5¹(.(z0', z1''), .(p(z3'', z4'', z0', r), z5'), member_out(p(x3', x4', x5', r))) → TURING_IN(t(.(x5', .(z0', z1'')), space, []), .(p(z3'', z4'', z0', r), z5')) at position [] and matcher [x4' / x4, z3'' / z3', x3' / x3, z5' / z5, z4'' / z4', x5' / x5, z0' / x5, z1'' / z1']

TURING_IN(t(.(x5, .(x5, z1')), space, []), .(p(z3', z4', x5, r), z5)) → U5¹(.(x5, .(x5, z1')), .(p(z3', z4', x5, r), z5), member_out(p(z3', z4', x5, r)))
with rule TURING_IN(t(.(z3, z0), space, []), .(p(z1, z2, z3, r), z4)) → U5¹(.(z3, z0), .(p(z1, z2, z3, r), z4), member_out(p(z1, z2, z3, r)))

Now applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence

All these steps are and every following step will be a correct step w.r.t to Q.

We use the technique of [30].Transforming Prolog into the following Term Rewriting System:
Pi-finite rewrite system:
The TRS R consists of the following rules:

turing_in(t([], Y, R), S, P, T) → U9(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
member_in(X, .(H, L)) → U1(X, H, L, member_in(X, L))
member_in(H, .(H, L)) → member_out(H, .(H, L))
U1(X, H, L, member_out(X, L)) → member_out(X, .(H, L))
U9(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U10(Y, R, S, P, T, turing_in(t([], space, .(W, R)), S1, P, T))
turing_in(t(.(X, L), Y, R), S, P, T) → U7(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
U7(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U8(X, L, Y, R, S, P, T, turing_in(t(L, X, .(W, R)), S1, P, T))
turing_in(t(X, Y, []), S, P, T) → U5(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))
U5(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U6(X, Y, S, P, T, turing_in(t(.(W, X), space, []), S1, P, T))
turing_in(t(X, Y, .(R, L)), S, P, T) → U3(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
U3(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U4(X, Y, R, L, S, P, T, turing_in(t(.(W, X), R, L), S1, P, T))
turing_in(t(X, Y, Z), S, P, t(X, Y, Z)) → U2(X, Y, Z, S, P, member_in(p(S, Y, halt, W, D), P))
U2(X, Y, Z, S, P, member_out(p(S, Y, halt, W, D), P)) → turing_out(t(X, Y, Z), S, P, t(X, Y, Z))
U4(X, Y, R, L, S, P, T, turing_out(t(.(W, X), R, L), S1, P, T)) → turing_out(t(X, Y, .(R, L)), S, P, T)
U6(X, Y, S, P, T, turing_out(t(.(W, X), space, []), S1, P, T)) → turing_out(t(X, Y, []), S, P, T)
U8(X, L, Y, R, S, P, T, turing_out(t(L, X, .(W, R)), S1, P, T)) → turing_out(t(.(X, L), Y, R), S, P, T)
U10(Y, R, S, P, T, turing_out(t([], space, .(W, R)), S1, P, T)) → turing_out(t([], Y, R), S, P, T)

Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

Pi-finite rewrite system:
The TRS R consists of the following rules:

turing_in(t([], Y, R), S, P, T) → U9(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
member_in(X, .(H, L)) → U1(X, H, L, member_in(X, L))
member_in(H, .(H, L)) → member_out(H, .(H, L))
U1(X, H, L, member_out(X, L)) → member_out(X, .(H, L))
U9(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U10(Y, R, S, P, T, turing_in(t([], space, .(W, R)), S1, P, T))
turing_in(t(.(X, L), Y, R), S, P, T) → U7(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
U7(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U8(X, L, Y, R, S, P, T, turing_in(t(L, X, .(W, R)), S1, P, T))
turing_in(t(X, Y, []), S, P, T) → U5(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))
U5(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U6(X, Y, S, P, T, turing_in(t(.(W, X), space, []), S1, P, T))
turing_in(t(X, Y, .(R, L)), S, P, T) → U3(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
U3(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U4(X, Y, R, L, S, P, T, turing_in(t(.(W, X), R, L), S1, P, T))
turing_in(t(X, Y, Z), S, P, t(X, Y, Z)) → U2(X, Y, Z, S, P, member_in(p(S, Y, halt, W, D), P))
U2(X, Y, Z, S, P, member_out(p(S, Y, halt, W, D), P)) → turing_out(t(X, Y, Z), S, P, t(X, Y, Z))
U4(X, Y, R, L, S, P, T, turing_out(t(.(W, X), R, L), S1, P, T)) → turing_out(t(X, Y, .(R, L)), S, P, T)
U6(X, Y, S, P, T, turing_out(t(.(W, X), space, []), S1, P, T)) → turing_out(t(X, Y, []), S, P, T)
U8(X, L, Y, R, S, P, T, turing_out(t(L, X, .(W, R)), S1, P, T)) → turing_out(t(.(X, L), Y, R), S, P, T)
U10(Y, R, S, P, T, turing_out(t([], space, .(W, R)), S1, P, T)) → turing_out(t([], Y, R), S, P, T)

TURING_IN(t([], Y, R), S, P, T) → U9¹(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
TURING_IN(t([], Y, R), S, P, T) → MEMBER_IN(p(S, Y, S1, W, l), P)
MEMBER_IN(X, .(H, L)) → U1¹(X, H, L, member_in(X, L))
MEMBER_IN(X, .(H, L)) → MEMBER_IN(X, L)
U9¹(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U10¹(Y, R, S, P, T, turing_in(t([], space, .(W, R)), S1, P, T))
U9¹(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → TURING_IN(t([], space, .(W, R)), S1, P, T)
TURING_IN(t(.(X, L), Y, R), S, P, T) → U7¹(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
TURING_IN(t(.(X, L), Y, R), S, P, T) → MEMBER_IN(p(S, Y, S1, W, l), P)
U7¹(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U8¹(X, L, Y, R, S, P, T, turing_in(t(L, X, .(W, R)), S1, P, T))
U7¹(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → TURING_IN(t(L, X, .(W, R)), S1, P, T)
TURING_IN(t(X, Y, []), S, P, T) → U5¹(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))
TURING_IN(t(X, Y, []), S, P, T) → MEMBER_IN(p(S, Y, S1, W, r), P)
U5¹(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U6¹(X, Y, S, P, T, turing_in(t(.(W, X), space, []), S1, P, T))
U5¹(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → TURING_IN(t(.(W, X), space, []), S1, P, T)
TURING_IN(t(X, Y, .(R, L)), S, P, T) → U3¹(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
TURING_IN(t(X, Y, .(R, L)), S, P, T) → MEMBER_IN(p(S, Y, S1, W, r), P)
U3¹(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U4¹(X, Y, R, L, S, P, T, turing_in(t(.(W, X), R, L), S1, P, T))
U3¹(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → TURING_IN(t(.(W, X), R, L), S1, P, T)
TURING_IN(t(X, Y, Z), S, P, t(X, Y, Z)) → U2¹(X, Y, Z, S, P, member_in(p(S, Y, halt, W, D), P))
TURING_IN(t(X, Y, Z), S, P, t(X, Y, Z)) → MEMBER_IN(p(S, Y, halt, W, D), P)

The TRS R consists of the following rules:

turing_in(t([], Y, R), S, P, T) → U9(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
member_in(X, .(H, L)) → U1(X, H, L, member_in(X, L))
member_in(H, .(H, L)) → member_out(H, .(H, L))
U1(X, H, L, member_out(X, L)) → member_out(X, .(H, L))
U9(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U10(Y, R, S, P, T, turing_in(t([], space, .(W, R)), S1, P, T))
turing_in(t(.(X, L), Y, R), S, P, T) → U7(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
U7(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U8(X, L, Y, R, S, P, T, turing_in(t(L, X, .(W, R)), S1, P, T))
turing_in(t(X, Y, []), S, P, T) → U5(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))
U5(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U6(X, Y, S, P, T, turing_in(t(.(W, X), space, []), S1, P, T))
turing_in(t(X, Y, .(R, L)), S, P, T) → U3(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
U3(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U4(X, Y, R, L, S, P, T, turing_in(t(.(W, X), R, L), S1, P, T))
turing_in(t(X, Y, Z), S, P, t(X, Y, Z)) → U2(X, Y, Z, S, P, member_in(p(S, Y, halt, W, D), P))
U2(X, Y, Z, S, P, member_out(p(S, Y, halt, W, D), P)) → turing_out(t(X, Y, Z), S, P, t(X, Y, Z))
U4(X, Y, R, L, S, P, T, turing_out(t(.(W, X), R, L), S1, P, T)) → turing_out(t(X, Y, .(R, L)), S, P, T)
U6(X, Y, S, P, T, turing_out(t(.(W, X), space, []), S1, P, T)) → turing_out(t(X, Y, []), S, P, T)
U8(X, L, Y, R, S, P, T, turing_out(t(L, X, .(W, R)), S1, P, T)) → turing_out(t(.(X, L), Y, R), S, P, T)
U10(Y, R, S, P, T, turing_out(t([], space, .(W, R)), S1, P, T)) → turing_out(t([], Y, R), S, P, T)

The argument filtering Pi contains the following mapping:
turing_in(x1, x2, x3, x4) = turing_in(x1, x3)
t(x1, x2, x3) = t(x1, x2, x3)
[] = []
U9(x1, x2, x3, x4, x5, x6) = U9(x1, x2, x4, x6)
member_in(x1, x2) = member_in(x2)
p(x1, x2, x3, x4, x5) = p(x1, x2, x4, x5)
l = l
.(x1, x2) = .(x1, x2)
U1(x1, x2, x3, x4) = U1(x2, x3, x4)
member_out(x1, x2) = member_out(x1, x2)
U10(x1, x2, x3, x4, x5, x6) = U10(x1, x2, x3, x4, x6)
space = space
U7(x1, x2, x3, x4, x5, x6, x7, x8) = U7(x1, x2, x3, x4, x6, x8)
U8(x1, x2, x3, x4, x5, x6, x7, x8) = U8(x1, x2, x3, x4, x5, x6, x8)
U5(x1, x2, x3, x4, x5, x6) = U5(x1, x2, x4, x6)
r = r
U6(x1, x2, x3, x4, x5, x6) = U6(x1, x2, x3, x4, x6)
U3(x1, x2, x3, x4, x5, x6, x7, x8) = U3(x1, x2, x3, x4, x6, x8)
U4(x1, x2, x3, x4, x5, x6, x7, x8) = U4(x1, x2, x3, x4, x5, x6, x8)
U2(x1, x2, x3, x4, x5, x6) = U2(x1, x2, x3, x5, x6)
halt = halt
turing_out(x1, x2, x3, x4) = turing_out(x1, x2, x3, x4)
U10¹(x1, x2, x3, x4, x5, x6) = U10¹(x1, x2, x3, x4, x6)
U5¹(x1, x2, x3, x4, x5, x6) = U5¹(x1, x2, x4, x6)
TURING_IN(x1, x2, x3, x4) = TURING_IN(x1, x3)
U2¹(x1, x2, x3, x4, x5, x6) = U2¹(x1, x2, x3, x5, x6)
U3¹(x1, x2, x3, x4, x5, x6, x7, x8) = U3¹(x1, x2, x3, x4, x6, x8)
MEMBER_IN(x1, x2) = MEMBER_IN(x2)
U9¹(x1, x2, x3, x4, x5, x6) = U9¹(x1, x2, x4, x6)
U7¹(x1, x2, x3, x4, x5, x6, x7, x8) = U7¹(x1, x2, x3, x4, x6, x8)
U4¹(x1, x2, x3, x4, x5, x6, x7, x8) = U4¹(x1, x2, x3, x4, x5, x6, x8)
U8¹(x1, x2, x3, x4, x5, x6, x7, x8) = U8¹(x1, x2, x3, x4, x5, x6, x8)
U6¹(x1, x2, x3, x4, x5, x6) = U6¹(x1, x2, x3, x4, x6)
U1¹(x1, x2, x3, x4) = U1¹(x2, x3, x4)

We have to consider all (P,R,Pi)-chains

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

Pi DP problem:
The TRS P consists of the following rules:

TURING_IN(t([], Y, R), S, P, T) → U9¹(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
TURING_IN(t([], Y, R), S, P, T) → MEMBER_IN(p(S, Y, S1, W, l), P)
MEMBER_IN(X, .(H, L)) → U1¹(X, H, L, member_in(X, L))
MEMBER_IN(X, .(H, L)) → MEMBER_IN(X, L)
U9¹(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U10¹(Y, R, S, P, T, turing_in(t([], space, .(W, R)), S1, P, T))
U9¹(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → TURING_IN(t([], space, .(W, R)), S1, P, T)
TURING_IN(t(.(X, L), Y, R), S, P, T) → U7¹(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
TURING_IN(t(.(X, L), Y, R), S, P, T) → MEMBER_IN(p(S, Y, S1, W, l), P)
U7¹(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U8¹(X, L, Y, R, S, P, T, turing_in(t(L, X, .(W, R)), S1, P, T))
U7¹(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → TURING_IN(t(L, X, .(W, R)), S1, P, T)
TURING_IN(t(X, Y, []), S, P, T) → U5¹(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))
TURING_IN(t(X, Y, []), S, P, T) → MEMBER_IN(p(S, Y, S1, W, r), P)
U5¹(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U6¹(X, Y, S, P, T, turing_in(t(.(W, X), space, []), S1, P, T))
U5¹(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → TURING_IN(t(.(W, X), space, []), S1, P, T)
TURING_IN(t(X, Y, .(R, L)), S, P, T) → U3¹(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
TURING_IN(t(X, Y, .(R, L)), S, P, T) → MEMBER_IN(p(S, Y, S1, W, r), P)
U3¹(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U4¹(X, Y, R, L, S, P, T, turing_in(t(.(W, X), R, L), S1, P, T))
U3¹(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → TURING_IN(t(.(W, X), R, L), S1, P, T)
TURING_IN(t(X, Y, Z), S, P, t(X, Y, Z)) → U2¹(X, Y, Z, S, P, member_in(p(S, Y, halt, W, D), P))
TURING_IN(t(X, Y, Z), S, P, t(X, Y, Z)) → MEMBER_IN(p(S, Y, halt, W, D), P)

The TRS R consists of the following rules:

turing_in(t([], Y, R), S, P, T) → U9(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
member_in(X, .(H, L)) → U1(X, H, L, member_in(X, L))
member_in(H, .(H, L)) → member_out(H, .(H, L))
U1(X, H, L, member_out(X, L)) → member_out(X, .(H, L))
U9(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U10(Y, R, S, P, T, turing_in(t([], space, .(W, R)), S1, P, T))
turing_in(t(.(X, L), Y, R), S, P, T) → U7(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
U7(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U8(X, L, Y, R, S, P, T, turing_in(t(L, X, .(W, R)), S1, P, T))
turing_in(t(X, Y, []), S, P, T) → U5(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))
U5(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U6(X, Y, S, P, T, turing_in(t(.(W, X), space, []), S1, P, T))
turing_in(t(X, Y, .(R, L)), S, P, T) → U3(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
U3(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U4(X, Y, R, L, S, P, T, turing_in(t(.(W, X), R, L), S1, P, T))
turing_in(t(X, Y, Z), S, P, t(X, Y, Z)) → U2(X, Y, Z, S, P, member_in(p(S, Y, halt, W, D), P))
U2(X, Y, Z, S, P, member_out(p(S, Y, halt, W, D), P)) → turing_out(t(X, Y, Z), S, P, t(X, Y, Z))
U4(X, Y, R, L, S, P, T, turing_out(t(.(W, X), R, L), S1, P, T)) → turing_out(t(X, Y, .(R, L)), S, P, T)
U6(X, Y, S, P, T, turing_out(t(.(W, X), space, []), S1, P, T)) → turing_out(t(X, Y, []), S, P, T)
U8(X, L, Y, R, S, P, T, turing_out(t(L, X, .(W, R)), S1, P, T)) → turing_out(t(.(X, L), Y, R), S, P, T)
U10(Y, R, S, P, T, turing_out(t([], space, .(W, R)), S1, P, T)) → turing_out(t([], Y, R), S, P, T)

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

                ↳ UsableRulesProof

              ↳ PiDP

Pi DP problem:
The TRS P consists of the following rules:

MEMBER_IN(X, .(H, L)) → MEMBER_IN(X, L)

The TRS R consists of the following rules:

turing_in(t([], Y, R), S, P, T) → U9(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
member_in(X, .(H, L)) → U1(X, H, L, member_in(X, L))
member_in(H, .(H, L)) → member_out(H, .(H, L))
U1(X, H, L, member_out(X, L)) → member_out(X, .(H, L))
U9(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U10(Y, R, S, P, T, turing_in(t([], space, .(W, R)), S1, P, T))
turing_in(t(.(X, L), Y, R), S, P, T) → U7(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
U7(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U8(X, L, Y, R, S, P, T, turing_in(t(L, X, .(W, R)), S1, P, T))
turing_in(t(X, Y, []), S, P, T) → U5(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))
U5(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U6(X, Y, S, P, T, turing_in(t(.(W, X), space, []), S1, P, T))
turing_in(t(X, Y, .(R, L)), S, P, T) → U3(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
U3(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U4(X, Y, R, L, S, P, T, turing_in(t(.(W, X), R, L), S1, P, T))
turing_in(t(X, Y, Z), S, P, t(X, Y, Z)) → U2(X, Y, Z, S, P, member_in(p(S, Y, halt, W, D), P))
U2(X, Y, Z, S, P, member_out(p(S, Y, halt, W, D), P)) → turing_out(t(X, Y, Z), S, P, t(X, Y, Z))
U4(X, Y, R, L, S, P, T, turing_out(t(.(W, X), R, L), S1, P, T)) → turing_out(t(X, Y, .(R, L)), S, P, T)
U6(X, Y, S, P, T, turing_out(t(.(W, X), space, []), S1, P, T)) → turing_out(t(X, Y, []), S, P, T)
U8(X, L, Y, R, S, P, T, turing_out(t(L, X, .(W, R)), S1, P, T)) → turing_out(t(.(X, L), Y, R), S, P, T)
U10(Y, R, S, P, T, turing_out(t([], space, .(W, R)), S1, P, T)) → turing_out(t([], Y, R), S, P, T)

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

              ↳ PiDP

Pi DP problem:
The TRS P consists of the following rules:

MEMBER_IN(X, .(H, L)) → MEMBER_IN(X, L)

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ PiDP

Q DP problem:
The TRS P consists of the following rules:

MEMBER_IN(.(H, L)) → MEMBER_IN(L)

From the DPs we obtained the following set of size-change graphs:

MEMBER_IN(.(H, L)) → MEMBER_IN(L)
The graph contains the following edges 1 > 1

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

Pi DP problem:
The TRS P consists of the following rules:

TURING_IN(t([], Y, R), S, P, T) → U9¹(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
U9¹(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → TURING_IN(t([], space, .(W, R)), S1, P, T)
U5¹(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → TURING_IN(t(.(W, X), space, []), S1, P, T)
TURING_IN(t(X, Y, .(R, L)), S, P, T) → U3¹(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
U7¹(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → TURING_IN(t(L, X, .(W, R)), S1, P, T)
U3¹(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → TURING_IN(t(.(W, X), R, L), S1, P, T)
TURING_IN(t(.(X, L), Y, R), S, P, T) → U7¹(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
TURING_IN(t(X, Y, []), S, P, T) → U5¹(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))

The TRS R consists of the following rules:

turing_in(t([], Y, R), S, P, T) → U9(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
member_in(X, .(H, L)) → U1(X, H, L, member_in(X, L))
member_in(H, .(H, L)) → member_out(H, .(H, L))
U1(X, H, L, member_out(X, L)) → member_out(X, .(H, L))
U9(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U10(Y, R, S, P, T, turing_in(t([], space, .(W, R)), S1, P, T))
turing_in(t(.(X, L), Y, R), S, P, T) → U7(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
U7(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → U8(X, L, Y, R, S, P, T, turing_in(t(L, X, .(W, R)), S1, P, T))
turing_in(t(X, Y, []), S, P, T) → U5(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))
U5(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U6(X, Y, S, P, T, turing_in(t(.(W, X), space, []), S1, P, T))
turing_in(t(X, Y, .(R, L)), S, P, T) → U3(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
U3(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → U4(X, Y, R, L, S, P, T, turing_in(t(.(W, X), R, L), S1, P, T))
turing_in(t(X, Y, Z), S, P, t(X, Y, Z)) → U2(X, Y, Z, S, P, member_in(p(S, Y, halt, W, D), P))
U2(X, Y, Z, S, P, member_out(p(S, Y, halt, W, D), P)) → turing_out(t(X, Y, Z), S, P, t(X, Y, Z))
U4(X, Y, R, L, S, P, T, turing_out(t(.(W, X), R, L), S1, P, T)) → turing_out(t(X, Y, .(R, L)), S, P, T)
U6(X, Y, S, P, T, turing_out(t(.(W, X), space, []), S1, P, T)) → turing_out(t(X, Y, []), S, P, T)
U8(X, L, Y, R, S, P, T, turing_out(t(L, X, .(W, R)), S1, P, T)) → turing_out(t(.(X, L), Y, R), S, P, T)
U10(Y, R, S, P, T, turing_out(t([], space, .(W, R)), S1, P, T)) → turing_out(t([], Y, R), S, P, T)

The argument filtering Pi contains the following mapping:
turing_in(x1, x2, x3, x4) = turing_in(x1, x3)
t(x1, x2, x3) = t(x1, x2, x3)
[] = []
U9(x1, x2, x3, x4, x5, x6) = U9(x1, x2, x4, x6)
member_in(x1, x2) = member_in(x2)
p(x1, x2, x3, x4, x5) = p(x1, x2, x4, x5)
l = l
.(x1, x2) = .(x1, x2)
U1(x1, x2, x3, x4) = U1(x2, x3, x4)
member_out(x1, x2) = member_out(x1, x2)
U10(x1, x2, x3, x4, x5, x6) = U10(x1, x2, x3, x4, x6)
space = space
U7(x1, x2, x3, x4, x5, x6, x7, x8) = U7(x1, x2, x3, x4, x6, x8)
U8(x1, x2, x3, x4, x5, x6, x7, x8) = U8(x1, x2, x3, x4, x5, x6, x8)
U5(x1, x2, x3, x4, x5, x6) = U5(x1, x2, x4, x6)
r = r
U6(x1, x2, x3, x4, x5, x6) = U6(x1, x2, x3, x4, x6)
U3(x1, x2, x3, x4, x5, x6, x7, x8) = U3(x1, x2, x3, x4, x6, x8)
U4(x1, x2, x3, x4, x5, x6, x7, x8) = U4(x1, x2, x3, x4, x5, x6, x8)
U2(x1, x2, x3, x4, x5, x6) = U2(x1, x2, x3, x5, x6)
halt = halt
turing_out(x1, x2, x3, x4) = turing_out(x1, x2, x3, x4)
U5¹(x1, x2, x3, x4, x5, x6) = U5¹(x1, x2, x4, x6)
TURING_IN(x1, x2, x3, x4) = TURING_IN(x1, x3)
U3¹(x1, x2, x3, x4, x5, x6, x7, x8) = U3¹(x1, x2, x3, x4, x6, x8)
U9¹(x1, x2, x3, x4, x5, x6) = U9¹(x1, x2, x4, x6)
U7¹(x1, x2, x3, x4, x5, x6, x7, x8) = U7¹(x1, x2, x3, x4, x6, x8)

We have to consider all (P,R,Pi)-chains
For (infinitary) constructor rewriting [30] we can delete all non-usable rules from R.

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

Pi DP problem:
The TRS P consists of the following rules:

TURING_IN(t([], Y, R), S, P, T) → U9¹(Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
U9¹(Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → TURING_IN(t([], space, .(W, R)), S1, P, T)
U5¹(X, Y, S, P, T, member_out(p(S, Y, S1, W, r), P)) → TURING_IN(t(.(W, X), space, []), S1, P, T)
TURING_IN(t(X, Y, .(R, L)), S, P, T) → U3¹(X, Y, R, L, S, P, T, member_in(p(S, Y, S1, W, r), P))
U7¹(X, L, Y, R, S, P, T, member_out(p(S, Y, S1, W, l), P)) → TURING_IN(t(L, X, .(W, R)), S1, P, T)
U3¹(X, Y, R, L, S, P, T, member_out(p(S, Y, S1, W, r), P)) → TURING_IN(t(.(W, X), R, L), S1, P, T)
TURING_IN(t(.(X, L), Y, R), S, P, T) → U7¹(X, L, Y, R, S, P, T, member_in(p(S, Y, S1, W, l), P))
TURING_IN(t(X, Y, []), S, P, T) → U5¹(X, Y, S, P, T, member_in(p(S, Y, S1, W, r), P))

The TRS R consists of the following rules:

member_in(X, .(H, L)) → U1(X, H, L, member_in(X, L))
member_in(H, .(H, L)) → member_out(H, .(H, L))
U1(X, H, L, member_out(X, L)) → member_out(X, .(H, L))

The argument filtering Pi contains the following mapping:
t(x1, x2, x3) = t(x1, x2, x3)
[] = []
member_in(x1, x2) = member_in(x2)
p(x1, x2, x3, x4, x5) = p(x1, x2, x4, x5)
l = l
.(x1, x2) = .(x1, x2)
U1(x1, x2, x3, x4) = U1(x2, x3, x4)
member_out(x1, x2) = member_out(x1, x2)
space = space
r = r
U5¹(x1, x2, x3, x4, x5, x6) = U5¹(x1, x2, x4, x6)
TURING_IN(x1, x2, x3, x4) = TURING_IN(x1, x3)
U3¹(x1, x2, x3, x4, x5, x6, x7, x8) = U3¹(x1, x2, x3, x4, x6, x8)
U9¹(x1, x2, x3, x4, x5, x6) = U9¹(x1, x2, x4, x6)
U7¹(x1, x2, x3, x4, x5, x6, x7, x8) = U7¹(x1, x2, x3, x4, x6, x8)

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

TURING_IN(t(X, Y, []), P) → U5¹(X, Y, P, member_in(P))
U7¹(X, L, Y, R, P, member_out(p(S, Y, W, l), P)) → TURING_IN(t(L, X, .(W, R)), P)
U3¹(X, Y, R, L, P, member_out(p(S, Y, W, r), P)) → TURING_IN(t(.(W, X), R, L), P)
TURING_IN(t(.(X, L), Y, R), P) → U7¹(X, L, Y, R, P, member_in(P))
TURING_IN(t(X, Y, .(R, L)), P) → U3¹(X, Y, R, L, P, member_in(P))
U9¹(Y, R, P, member_out(p(S, Y, W, l), P)) → TURING_IN(t([], space, .(W, R)), P)
U5¹(X, Y, P, member_out(p(S, Y, W, r), P)) → TURING_IN(t(.(W, X), space, []), P)
TURING_IN(t([], Y, R), P) → U9¹(Y, R, P, member_in(P))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule TURING_IN(t([], Y, R), P) → U9¹(Y, R, P, member_in(P)) at position [3] we obtained the following new rules:

TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

TURING_IN(t(X, Y, []), P) → U5¹(X, Y, P, member_in(P))
U7¹(X, L, Y, R, P, member_out(p(S, Y, W, l), P)) → TURING_IN(t(L, X, .(W, R)), P)
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1)))
U3¹(X, Y, R, L, P, member_out(p(S, Y, W, r), P)) → TURING_IN(t(.(W, X), R, L), P)
TURING_IN(t(.(X, L), Y, R), P) → U7¹(X, L, Y, R, P, member_in(P))
TURING_IN(t(X, Y, .(R, L)), P) → U3¹(X, Y, R, L, P, member_in(P))
U9¹(Y, R, P, member_out(p(S, Y, W, l), P)) → TURING_IN(t([], space, .(W, R)), P)
U5¹(X, Y, P, member_out(p(S, Y, W, r), P)) → TURING_IN(t(.(W, X), space, []), P)
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule TURING_IN(t(X, Y, .(R, L)), P) → U3¹(X, Y, R, L, P, member_in(P)) at position [5] we obtained the following new rules:

TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

TURING_IN(t(X, Y, []), P) → U5¹(X, Y, P, member_in(P))
U7¹(X, L, Y, R, P, member_out(p(S, Y, W, l), P)) → TURING_IN(t(L, X, .(W, R)), P)
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1)))
U3¹(X, Y, R, L, P, member_out(p(S, Y, W, r), P)) → TURING_IN(t(.(W, X), R, L), P)
TURING_IN(t(.(X, L), Y, R), P) → U7¹(X, L, Y, R, P, member_in(P))
U9¹(Y, R, P, member_out(p(S, Y, W, l), P)) → TURING_IN(t([], space, .(W, R)), P)
U5¹(X, Y, P, member_out(p(S, Y, W, r), P)) → TURING_IN(t(.(W, X), space, []), P)
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule TURING_IN(t(.(X, L), Y, R), P) → U7¹(X, L, Y, R, P, member_in(P)) at position [5] we obtained the following new rules:

TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

TURING_IN(t(X, Y, []), P) → U5¹(X, Y, P, member_in(P))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
U7¹(X, L, Y, R, P, member_out(p(S, Y, W, l), P)) → TURING_IN(t(L, X, .(W, R)), P)
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
U3¹(X, Y, R, L, P, member_out(p(S, Y, W, r), P)) → TURING_IN(t(.(W, X), R, L), P)
U9¹(Y, R, P, member_out(p(S, Y, W, l), P)) → TURING_IN(t([], space, .(W, R)), P)
U5¹(X, Y, P, member_out(p(S, Y, W, r), P)) → TURING_IN(t(.(W, X), space, []), P)
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule TURING_IN(t(X, Y, []), P) → U5¹(X, Y, P, member_in(P)) at position [3] we obtained the following new rules:

TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

U7¹(X, L, Y, R, P, member_out(p(S, Y, W, l), P)) → TURING_IN(t(L, X, .(W, R)), P)
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
U3¹(X, Y, R, L, P, member_out(p(S, Y, W, r), P)) → TURING_IN(t(.(W, X), R, L), P)
U9¹(Y, R, P, member_out(p(S, Y, W, l), P)) → TURING_IN(t([], space, .(W, R)), P)
U5¹(X, Y, P, member_out(p(S, Y, W, r), P)) → TURING_IN(t(.(W, X), space, []), P)
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U9¹(Y, R, P, member_out(p(S, Y, W, l), P)) → TURING_IN(t([], space, .(W, R)), P) we obtained the following new rules:

U9¹(z0, z1, .(z2, z3), member_out(p(x3, z0, x4, l), .(z2, z3))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))
U9¹(z0, z1, .(p(x3, z0, x4, l), z3), member_out(p(x3, z0, x4, l), .(p(x3, z0, x4, l), z3))) → TURING_IN(t([], space, .(x4, z1)), .(p(x3, z0, x4, l), z3))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

U7¹(X, L, Y, R, P, member_out(p(S, Y, W, l), P)) → TURING_IN(t(L, X, .(W, R)), P)
U9¹(z0, z1, .(z2, z3), member_out(p(x3, z0, x4, l), .(z2, z3))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))
U9¹(z0, z1, .(p(x3, z0, x4, l), z3), member_out(p(x3, z0, x4, l), .(p(x3, z0, x4, l), z3))) → TURING_IN(t([], space, .(x4, z1)), .(p(x3, z0, x4, l), z3))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1)))
U3¹(X, Y, R, L, P, member_out(p(S, Y, W, r), P)) → TURING_IN(t(.(W, X), R, L), P)
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1)))
U5¹(X, Y, P, member_out(p(S, Y, W, r), P)) → TURING_IN(t(.(W, X), space, []), P)
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U5¹(X, Y, P, member_out(p(S, Y, W, r), P)) → TURING_IN(t(.(W, X), space, []), P) we obtained the following new rules:

U5¹(z0, z1, .(p(x3, z1, x4, r), z3), member_out(p(x3, z1, x4, r), .(p(x3, z1, x4, r), z3))) → TURING_IN(t(.(x4, z0), space, []), .(p(x3, z1, x4, r), z3))
U5¹(z0, z1, .(z2, z3), member_out(p(x3, z1, x4, r), .(z2, z3))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

U7¹(X, L, Y, R, P, member_out(p(S, Y, W, l), P)) → TURING_IN(t(L, X, .(W, R)), P)
U9¹(z0, z1, .(z2, z3), member_out(p(x3, z0, x4, l), .(z2, z3))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))
U9¹(z0, z1, .(p(x3, z0, x4, l), z3), member_out(p(x3, z0, x4, l), .(p(x3, z0, x4, l), z3))) → TURING_IN(t([], space, .(x4, z1)), .(p(x3, z0, x4, l), z3))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
U3¹(X, Y, R, L, P, member_out(p(S, Y, W, r), P)) → TURING_IN(t(.(W, X), R, L), P)
U5¹(z0, z1, .(p(x3, z1, x4, r), z3), member_out(p(x3, z1, x4, r), .(p(x3, z1, x4, r), z3))) → TURING_IN(t(.(x4, z0), space, []), .(p(x3, z1, x4, r), z3))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))
U5¹(z0, z1, .(z2, z3), member_out(p(x3, z1, x4, r), .(z2, z3))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U7¹(X, L, Y, R, P, member_out(p(S, Y, W, l), P)) → TURING_IN(t(L, X, .(W, R)), P) we obtained the following new rules:

U7¹(z0, z1, z2, z3, .(p(x5, z2, x6, l), z5), member_out(p(x5, z2, x6, l), .(p(x5, z2, x6, l), z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x5, z2, x6, l), z5))
U7¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z2, x6, l), .(z4, z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

U9¹(z0, z1, .(z2, z3), member_out(p(x3, z0, x4, l), .(z2, z3))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))
U9¹(z0, z1, .(p(x3, z0, x4, l), z3), member_out(p(x3, z0, x4, l), .(p(x3, z0, x4, l), z3))) → TURING_IN(t([], space, .(x4, z1)), .(p(x3, z0, x4, l), z3))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1)))
U7¹(z0, z1, z2, z3, .(p(x5, z2, x6, l), z5), member_out(p(x5, z2, x6, l), .(p(x5, z2, x6, l), z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x5, z2, x6, l), z5))
U3¹(X, Y, R, L, P, member_out(p(S, Y, W, r), P)) → TURING_IN(t(.(W, X), R, L), P)
U7¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z2, x6, l), .(z4, z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
U5¹(z0, z1, .(p(x3, z1, x4, r), z3), member_out(p(x3, z1, x4, r), .(p(x3, z1, x4, r), z3))) → TURING_IN(t(.(x4, z0), space, []), .(p(x3, z1, x4, r), z3))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
U5¹(z0, z1, .(z2, z3), member_out(p(x3, z1, x4, r), .(z2, z3))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U3¹(X, Y, R, L, P, member_out(p(S, Y, W, r), P)) → TURING_IN(t(.(W, X), R, L), P) we obtained the following new rules:

U3¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z1, x6, r), .(z4, z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
U3¹(z0, z1, z2, z3, .(p(x5, z1, x6, r), z5), member_out(p(x5, z1, x6, r), .(p(x5, z1, x6, r), z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x5, z1, x6, r), z5))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

U9¹(z0, z1, .(z2, z3), member_out(p(x3, z0, x4, l), .(z2, z3))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))
U9¹(z0, z1, .(p(x3, z0, x4, l), z3), member_out(p(x3, z0, x4, l), .(p(x3, z0, x4, l), z3))) → TURING_IN(t([], space, .(x4, z1)), .(p(x3, z0, x4, l), z3))
U3¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z1, x6, r), .(z4, z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
U3¹(z0, z1, z2, z3, .(p(x5, z1, x6, r), z5), member_out(p(x5, z1, x6, r), .(p(x5, z1, x6, r), z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x5, z1, x6, r), z5))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
U7¹(z0, z1, z2, z3, .(p(x5, z2, x6, l), z5), member_out(p(x5, z2, x6, l), .(p(x5, z2, x6, l), z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x5, z2, x6, l), z5))
U5¹(z0, z1, .(p(x3, z1, x4, r), z3), member_out(p(x3, z1, x4, r), .(p(x3, z1, x4, r), z3))) → TURING_IN(t(.(x4, z0), space, []), .(p(x3, z1, x4, r), z3))
U7¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z2, x6, l), .(z4, z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))
U5¹(z0, z1, .(z2, z3), member_out(p(x3, z1, x4, r), .(z2, z3))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1))) we obtained the following new rules:

TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), U1(z2, z3, member_in(z3)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), U1(p(z4, z2, z5, l), z6, member_in(z6)))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), U1(p(z2, z0, z3, l), z4, member_in(z4)))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), U1(z4, z5, member_in(z5)))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), U1(z2, z3, member_in(z3)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), U1(p(z4, z2, z5, l), z6, member_in(z6)))
U9¹(z0, z1, .(z2, z3), member_out(p(x3, z0, x4, l), .(z2, z3))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), U1(p(z2, z0, z3, l), z4, member_in(z4)))
U9¹(z0, z1, .(p(x3, z0, x4, l), z3), member_out(p(x3, z0, x4, l), .(p(x3, z0, x4, l), z3))) → TURING_IN(t([], space, .(x4, z1)), .(p(x3, z0, x4, l), z3))
U3¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z1, x6, r), .(z4, z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
U3¹(z0, z1, z2, z3, .(p(x5, z1, x6, r), z5), member_out(p(x5, z1, x6, r), .(p(x5, z1, x6, r), z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x5, z1, x6, r), z5))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
U7¹(z0, z1, z2, z3, .(p(x5, z2, x6, l), z5), member_out(p(x5, z2, x6, l), .(p(x5, z2, x6, l), z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x5, z2, x6, l), z5))
U7¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z2, x6, l), .(z4, z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
U5¹(z0, z1, .(p(x3, z1, x4, r), z3), member_out(p(x3, z1, x4, r), .(p(x3, z1, x4, r), z3))) → TURING_IN(t(.(x4, z0), space, []), .(p(x3, z1, x4, r), z3))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), U1(z4, z5, member_in(z5)))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
U5¹(z0, z1, .(z2, z3), member_out(p(x3, z1, x4, r), .(z2, z3))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule TURING_IN(t([], y0, y1), .(x0, x1)) → U9¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1))) we obtained the following new rules:

TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), member_out(p(z4, z2, z5, l), .(p(z4, z2, z5, l), z6)))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), member_out(z4, .(z4, z5)))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), member_out(p(z2, z0, z3, l), .(p(z2, z0, z3, l), z4)))
TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), member_out(z2, .(z2, z3)))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), U1(z2, z3, member_in(z3)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), member_out(p(z4, z2, z5, l), .(p(z4, z2, z5, l), z6)))
U9¹(z0, z1, .(z2, z3), member_out(p(x3, z0, x4, l), .(z2, z3))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), U1(p(z4, z2, z5, l), z6, member_in(z6)))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), member_out(z4, .(z4, z5)))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), member_out(p(z2, z0, z3, l), .(p(z2, z0, z3, l), z4)))
U9¹(z0, z1, .(p(x3, z0, x4, l), z3), member_out(p(x3, z0, x4, l), .(p(x3, z0, x4, l), z3))) → TURING_IN(t([], space, .(x4, z1)), .(p(x3, z0, x4, l), z3))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), U1(p(z2, z0, z3, l), z4, member_in(z4)))
U3¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z1, x6, r), .(z4, z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), member_out(z2, .(z2, z3)))
U3¹(z0, z1, z2, z3, .(p(x5, z1, x6, r), z5), member_out(p(x5, z1, x6, r), .(p(x5, z1, x6, r), z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x5, z1, x6, r), z5))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
U7¹(z0, z1, z2, z3, .(p(x5, z2, x6, l), z5), member_out(p(x5, z2, x6, l), .(p(x5, z2, x6, l), z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x5, z2, x6, l), z5))
U5¹(z0, z1, .(p(x3, z1, x4, r), z3), member_out(p(x3, z1, x4, r), .(p(x3, z1, x4, r), z3))) → TURING_IN(t(.(x4, z0), space, []), .(p(x3, z1, x4, r), z3))
U7¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z2, x6, l), .(z4, z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), U1(z4, z5, member_in(z5)))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1)))
U5¹(z0, z1, .(z2, z3), member_out(p(x3, z1, x4, r), .(z2, z3))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), U1(x0, x1, member_in(x1))) we obtained the following new rules:

TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), U1(p(z2, z1, z3, r), z4, member_in(z4)))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), U1(p(z4, z1, z5, r), z6, member_in(z6)))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), U1(z2, z3, member_in(z3)))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), U1(z4, z5, member_in(z5)))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), U1(z2, z3, member_in(z3)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), member_out(p(z4, z2, z5, l), .(p(z4, z2, z5, l), z6)))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), member_out(z4, .(z4, z5)))
U3¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z1, x6, r), .(z4, z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), U1(z2, z3, member_in(z3)))
TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
U7¹(z0, z1, z2, z3, .(p(x5, z2, x6, l), z5), member_out(p(x5, z2, x6, l), .(p(x5, z2, x6, l), z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x5, z2, x6, l), z5))
U7¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z2, x6, l), .(z4, z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), U1(p(z4, z1, z5, r), z6, member_in(z6)))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), U1(z4, z5, member_in(z5)))
U5¹(z0, z1, .(z2, z3), member_out(p(x3, z1, x4, r), .(z2, z3))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))
U9¹(z0, z1, .(z2, z3), member_out(p(x3, z0, x4, l), .(z2, z3))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), U1(p(z4, z2, z5, l), z6, member_in(z6)))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), member_out(p(z2, z0, z3, l), .(p(z2, z0, z3, l), z4)))
U9¹(z0, z1, .(p(x3, z0, x4, l), z3), member_out(p(x3, z0, x4, l), .(p(x3, z0, x4, l), z3))) → TURING_IN(t([], space, .(x4, z1)), .(p(x3, z0, x4, l), z3))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), U1(p(z2, z0, z3, l), z4, member_in(z4)))
TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), member_out(z2, .(z2, z3)))
U3¹(z0, z1, z2, z3, .(p(x5, z1, x6, r), z5), member_out(p(x5, z1, x6, r), .(p(x5, z1, x6, r), z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x5, z1, x6, r), z5))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), U1(p(z2, z1, z3, r), z4, member_in(z4)))
U5¹(z0, z1, .(p(x3, z1, x4, r), z3), member_out(p(x3, z1, x4, r), .(p(x3, z1, x4, r), z3))) → TURING_IN(t(.(x4, z0), space, []), .(p(x3, z1, x4, r), z3))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), U1(z4, z5, member_in(z5)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule TURING_IN(t(y0, y1, []), .(x0, x1)) → U5¹(y0, y1, .(x0, x1), member_out(x0, .(x0, x1))) we obtained the following new rules:

TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), member_out(z4, .(z4, z5)))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), member_out(p(z2, z1, z3, r), .(p(z2, z1, z3, r), z4)))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), member_out(p(z4, z1, z5, r), .(p(z4, z1, z5, r), z6)))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), member_out(z2, .(z2, z3)))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), U1(z2, z3, member_in(z3)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), member_out(p(z4, z2, z5, l), .(p(z4, z2, z5, l), z6)))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), member_out(z4, .(z4, z5)))
U3¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z1, x6, r), .(z4, z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), U1(z2, z3, member_in(z3)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
U7¹(z0, z1, z2, z3, .(p(x5, z2, x6, l), z5), member_out(p(x5, z2, x6, l), .(p(x5, z2, x6, l), z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x5, z2, x6, l), z5))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), member_out(p(z2, z1, z3, r), .(p(z2, z1, z3, r), z4)))
U7¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z2, x6, l), .(z4, z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), U1(p(z4, z1, z5, r), z6, member_in(z6)))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), U1(z4, z5, member_in(z5)))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), member_out(z2, .(z2, z3)))
U5¹(z0, z1, .(z2, z3), member_out(p(x3, z1, x4, r), .(z2, z3))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), U1(p(z4, z2, z5, l), z6, member_in(z6)))
U9¹(z0, z1, .(z2, z3), member_out(p(x3, z0, x4, l), .(z2, z3))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), member_out(z4, .(z4, z5)))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), member_out(p(z2, z0, z3, l), .(p(z2, z0, z3, l), z4)))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), U1(p(z2, z0, z3, l), z4, member_in(z4)))
U9¹(z0, z1, .(p(x3, z0, x4, l), z3), member_out(p(x3, z0, x4, l), .(p(x3, z0, x4, l), z3))) → TURING_IN(t([], space, .(x4, z1)), .(p(x3, z0, x4, l), z3))
TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), member_out(z2, .(z2, z3)))
U3¹(z0, z1, z2, z3, .(p(x5, z1, x6, r), z5), member_out(p(x5, z1, x6, r), .(p(x5, z1, x6, r), z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x5, z1, x6, r), z5))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), U1(p(z2, z1, z3, r), z4, member_in(z4)))
U5¹(z0, z1, .(p(x3, z1, x4, r), z3), member_out(p(x3, z1, x4, r), .(p(x3, z1, x4, r), z3))) → TURING_IN(t(.(x4, z0), space, []), .(p(x3, z1, x4, r), z3))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), U1(z4, z5, member_in(z5)))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), member_out(p(z4, z1, z5, r), .(p(z4, z1, z5, r), z6)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U9¹(z0, z1, .(z2, z3), member_out(p(x3, z0, x4, l), .(z2, z3))) → TURING_IN(t([], space, .(x4, z1)), .(z2, z3)) we obtained the following new rules:

U9¹(space, .(z0, z1), .(p(x4, space, x5, l), z3), member_out(p(x4, space, x5, l), .(p(x4, space, x5, l), z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(x4, space, x5, l), z3))
U9¹(space, .(z0, z1), .(z2, z3), member_out(p(x4, space, x5, l), .(z2, z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(z2, z3))
U9¹(space, .(z0, z1), .(p(z2, space, z0, l), z4), member_out(p(z2, space, z0, l), .(p(z2, space, z0, l), z4))) → TURING_IN(t([], space, .(z0, .(z0, z1))), .(p(z2, space, z0, l), z4))
U9¹(z0, .(z1, z2), .(p(z3, z0, z1, l), z5), member_out(p(z3, z0, z1, l), .(p(z3, z0, z1, l), z5))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z0, z1, l), z5))
U9¹(space, .(z0, z1), .(p(z2, z3, z0, l), z4), member_out(p(x4, space, x5, l), .(p(z2, z3, z0, l), z4))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(z2, z3, z0, l), z4))
U9¹(z0, .(z1, z2), .(p(x4, z0, x5, l), z4), member_out(p(x4, z0, x5, l), .(p(x4, z0, x5, l), z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(x4, z0, x5, l), z4))
U9¹(z0, .(z1, z2), .(z3, z4), member_out(p(x4, z0, x5, l), .(z3, z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
U9¹(z0, .(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x4, z0, x5, l), .(p(z3, z4, z1, l), z5))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

U9¹(space, .(z0, z1), .(p(x4, space, x5, l), z3), member_out(p(x4, space, x5, l), .(p(x4, space, x5, l), z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(x4, space, x5, l), z3))
TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), U1(z2, z3, member_in(z3)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), member_out(p(z4, z2, z5, l), .(p(z4, z2, z5, l), z6)))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), member_out(z4, .(z4, z5)))
U9¹(z0, .(z1, z2), .(p(z3, z0, z1, l), z5), member_out(p(z3, z0, z1, l), .(p(z3, z0, z1, l), z5))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z0, z1, l), z5))
U3¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z1, x6, r), .(z4, z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
U9¹(z0, .(z1, z2), .(z3, z4), member_out(p(x4, z0, x5, l), .(z3, z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), U1(z2, z3, member_in(z3)))
U9¹(z0, .(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x4, z0, x5, l), .(p(z3, z4, z1, l), z5))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
U7¹(z0, z1, z2, z3, .(p(x5, z2, x6, l), z5), member_out(p(x5, z2, x6, l), .(p(x5, z2, x6, l), z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x5, z2, x6, l), z5))
U7¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z2, x6, l), .(z4, z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), member_out(p(z2, z1, z3, r), .(p(z2, z1, z3, r), z4)))
U9¹(space, .(z0, z1), .(p(z2, space, z0, l), z4), member_out(p(z2, space, z0, l), .(p(z2, space, z0, l), z4))) → TURING_IN(t([], space, .(z0, .(z0, z1))), .(p(z2, space, z0, l), z4))
U9¹(space, .(z0, z1), .(p(z2, z3, z0, l), z4), member_out(p(x4, space, x5, l), .(p(z2, z3, z0, l), z4))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(z2, z3, z0, l), z4))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), U1(p(z4, z1, z5, r), z6, member_in(z6)))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), U1(z4, z5, member_in(z5)))
U5¹(z0, z1, .(z2, z3), member_out(p(x3, z1, x4, r), .(z2, z3))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), member_out(z2, .(z2, z3)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), U1(p(z4, z2, z5, l), z6, member_in(z6)))
U9¹(space, .(z0, z1), .(z2, z3), member_out(p(x4, space, x5, l), .(z2, z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(z2, z3))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), member_out(p(z2, z0, z3, l), .(p(z2, z0, z3, l), z4)))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), member_out(z4, .(z4, z5)))
U9¹(z0, z1, .(p(x3, z0, x4, l), z3), member_out(p(x3, z0, x4, l), .(p(x3, z0, x4, l), z3))) → TURING_IN(t([], space, .(x4, z1)), .(p(x3, z0, x4, l), z3))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), U1(p(z2, z0, z3, l), z4, member_in(z4)))
TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), member_out(z2, .(z2, z3)))
U3¹(z0, z1, z2, z3, .(p(x5, z1, x6, r), z5), member_out(p(x5, z1, x6, r), .(p(x5, z1, x6, r), z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x5, z1, x6, r), z5))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), U1(p(z2, z1, z3, r), z4, member_in(z4)))
U5¹(z0, z1, .(p(x3, z1, x4, r), z3), member_out(p(x3, z1, x4, r), .(p(x3, z1, x4, r), z3))) → TURING_IN(t(.(x4, z0), space, []), .(p(x3, z1, x4, r), z3))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), U1(z4, z5, member_in(z5)))
U9¹(z0, .(z1, z2), .(p(x4, z0, x5, l), z4), member_out(p(x4, z0, x5, l), .(p(x4, z0, x5, l), z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(x4, z0, x5, l), z4))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), member_out(p(z4, z1, z5, r), .(p(z4, z1, z5, r), z6)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U9¹(z0, z1, .(p(x3, z0, x4, l), z3), member_out(p(x3, z0, x4, l), .(p(x3, z0, x4, l), z3))) → TURING_IN(t([], space, .(x4, z1)), .(p(x3, z0, x4, l), z3)) we obtained the following new rules:

U9¹(space, .(z0, z1), .(p(x2, space, x3, l), z3), member_out(p(x2, space, x3, l), .(p(x2, space, x3, l), z3))) → TURING_IN(t([], space, .(x3, .(z0, z1))), .(p(x2, space, x3, l), z3))
U9¹(space, .(z0, z1), .(p(z2, space, z0, l), z4), member_out(p(z2, space, z0, l), .(p(z2, space, z0, l), z4))) → TURING_IN(t([], space, .(z0, .(z0, z1))), .(p(z2, space, z0, l), z4))
U9¹(z0, .(z1, z2), .(p(z3, z0, z1, l), z5), member_out(p(z3, z0, z1, l), .(p(z3, z0, z1, l), z5))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z0, z1, l), z5))
U9¹(z0, .(z1, z2), .(p(x2, z0, x3, l), z4), member_out(p(x2, z0, x3, l), .(p(x2, z0, x3, l), z4))) → TURING_IN(t([], space, .(x3, .(z1, z2))), .(p(x2, z0, x3, l), z4))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

                                                                              ↳ QDP

                                                                                ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), U1(z2, z3, member_in(z3)))
U9¹(space, .(z0, z1), .(p(x4, space, x5, l), z3), member_out(p(x4, space, x5, l), .(p(x4, space, x5, l), z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(x4, space, x5, l), z3))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), member_out(p(z4, z2, z5, l), .(p(z4, z2, z5, l), z6)))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), member_out(z4, .(z4, z5)))
U3¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z1, x6, r), .(z4, z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
U9¹(z0, .(z1, z2), .(p(z3, z0, z1, l), z5), member_out(p(z3, z0, z1, l), .(p(z3, z0, z1, l), z5))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z0, z1, l), z5))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), U1(z2, z3, member_in(z3)))
U9¹(z0, .(z1, z2), .(z3, z4), member_out(p(x4, z0, x5, l), .(z3, z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
U9¹(z0, .(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x4, z0, x5, l), .(p(z3, z4, z1, l), z5))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
U7¹(z0, z1, z2, z3, .(p(x5, z2, x6, l), z5), member_out(p(x5, z2, x6, l), .(p(x5, z2, x6, l), z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x5, z2, x6, l), z5))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), member_out(p(z2, z1, z3, r), .(p(z2, z1, z3, r), z4)))
U7¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z2, x6, l), .(z4, z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
U9¹(space, .(z0, z1), .(p(z2, space, z0, l), z4), member_out(p(z2, space, z0, l), .(p(z2, space, z0, l), z4))) → TURING_IN(t([], space, .(z0, .(z0, z1))), .(p(z2, space, z0, l), z4))
U9¹(space, .(z0, z1), .(p(z2, z3, z0, l), z4), member_out(p(x4, space, x5, l), .(p(z2, z3, z0, l), z4))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(z2, z3, z0, l), z4))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), U1(p(z4, z1, z5, r), z6, member_in(z6)))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), U1(z4, z5, member_in(z5)))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), member_out(z2, .(z2, z3)))
U5¹(z0, z1, .(z2, z3), member_out(p(x3, z1, x4, r), .(z2, z3))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), U1(p(z4, z2, z5, l), z6, member_in(z6)))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), member_out(z4, .(z4, z5)))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), member_out(p(z2, z0, z3, l), .(p(z2, z0, z3, l), z4)))
U9¹(space, .(z0, z1), .(z2, z3), member_out(p(x4, space, x5, l), .(z2, z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(z2, z3))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), U1(p(z2, z0, z3, l), z4, member_in(z4)))
TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), member_out(z2, .(z2, z3)))
U3¹(z0, z1, z2, z3, .(p(x5, z1, x6, r), z5), member_out(p(x5, z1, x6, r), .(p(x5, z1, x6, r), z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x5, z1, x6, r), z5))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), U1(p(z2, z1, z3, r), z4, member_in(z4)))
U5¹(z0, z1, .(p(x3, z1, x4, r), z3), member_out(p(x3, z1, x4, r), .(p(x3, z1, x4, r), z3))) → TURING_IN(t(.(x4, z0), space, []), .(p(x3, z1, x4, r), z3))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), U1(z4, z5, member_in(z5)))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), member_out(p(z4, z1, z5, r), .(p(z4, z1, z5, r), z6)))
U9¹(z0, .(z1, z2), .(p(x4, z0, x5, l), z4), member_out(p(x4, z0, x5, l), .(p(x4, z0, x5, l), z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(x4, z0, x5, l), z4))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U5¹(z0, z1, .(p(x3, z1, x4, r), z3), member_out(p(x3, z1, x4, r), .(p(x3, z1, x4, r), z3))) → TURING_IN(t(.(x4, z0), space, []), .(p(x3, z1, x4, r), z3)) we obtained the following new rules:

U5¹(.(z0, z1), space, .(p(x2, space, x3, r), z3), member_out(p(x2, space, x3, r), .(p(x2, space, x3, r), z3))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x2, space, x3, r), z3))
U5¹(.(z0, z1), z2, .(p(z3, z2, z0, r), z5), member_out(p(z3, z2, z0, r), .(p(z3, z2, z0, r), z5))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z2, z0, r), z5))
U5¹(.(z0, z1), z2, .(p(x2, z2, x3, r), z4), member_out(p(x2, z2, x3, r), .(p(x2, z2, x3, r), z4))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x2, z2, x3, r), z4))
U5¹(.(z0, z1), space, .(p(z2, space, z0, r), z4), member_out(p(z2, space, z0, r), .(p(z2, space, z0, r), z4))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z2, space, z0, r), z4))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

U9¹(space, .(z0, z1), .(p(x4, space, x5, l), z3), member_out(p(x4, space, x5, l), .(p(x4, space, x5, l), z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(x4, space, x5, l), z3))
TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), U1(z2, z3, member_in(z3)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), member_out(p(z4, z2, z5, l), .(p(z4, z2, z5, l), z6)))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), member_out(z4, .(z4, z5)))
U5¹(.(z0, z1), space, .(p(x2, space, x3, r), z3), member_out(p(x2, space, x3, r), .(p(x2, space, x3, r), z3))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x2, space, x3, r), z3))
U9¹(z0, .(z1, z2), .(p(z3, z0, z1, l), z5), member_out(p(z3, z0, z1, l), .(p(z3, z0, z1, l), z5))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z0, z1, l), z5))
U3¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z1, x6, r), .(z4, z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
U5¹(.(z0, z1), z2, .(p(x2, z2, x3, r), z4), member_out(p(x2, z2, x3, r), .(p(x2, z2, x3, r), z4))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x2, z2, x3, r), z4))
U9¹(z0, .(z1, z2), .(z3, z4), member_out(p(x4, z0, x5, l), .(z3, z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), U1(z2, z3, member_in(z3)))
U9¹(z0, .(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x4, z0, x5, l), .(p(z3, z4, z1, l), z5))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
U7¹(z0, z1, z2, z3, .(p(x5, z2, x6, l), z5), member_out(p(x5, z2, x6, l), .(p(x5, z2, x6, l), z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x5, z2, x6, l), z5))
U7¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z2, x6, l), .(z4, z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), member_out(p(z2, z1, z3, r), .(p(z2, z1, z3, r), z4)))
U9¹(space, .(z0, z1), .(p(z2, space, z0, l), z4), member_out(p(z2, space, z0, l), .(p(z2, space, z0, l), z4))) → TURING_IN(t([], space, .(z0, .(z0, z1))), .(p(z2, space, z0, l), z4))
U9¹(space, .(z0, z1), .(p(z2, z3, z0, l), z4), member_out(p(x4, space, x5, l), .(p(z2, z3, z0, l), z4))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(z2, z3, z0, l), z4))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), U1(p(z4, z1, z5, r), z6, member_in(z6)))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), U1(z4, z5, member_in(z5)))
U5¹(z0, z1, .(z2, z3), member_out(p(x3, z1, x4, r), .(z2, z3))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), member_out(z2, .(z2, z3)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), U1(p(z4, z2, z5, l), z6, member_in(z6)))
U9¹(space, .(z0, z1), .(z2, z3), member_out(p(x4, space, x5, l), .(z2, z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(z2, z3))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), member_out(p(z2, z0, z3, l), .(p(z2, z0, z3, l), z4)))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), member_out(z4, .(z4, z5)))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), U1(p(z2, z0, z3, l), z4, member_in(z4)))
TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), member_out(z2, .(z2, z3)))
U3¹(z0, z1, z2, z3, .(p(x5, z1, x6, r), z5), member_out(p(x5, z1, x6, r), .(p(x5, z1, x6, r), z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x5, z1, x6, r), z5))
U5¹(.(z0, z1), space, .(p(z2, space, z0, r), z4), member_out(p(z2, space, z0, r), .(p(z2, space, z0, r), z4))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z2, space, z0, r), z4))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), U1(p(z2, z1, z3, r), z4, member_in(z4)))
U5¹(.(z0, z1), z2, .(p(z3, z2, z0, r), z5), member_out(p(z3, z2, z0, r), .(p(z3, z2, z0, r), z5))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z2, z0, r), z5))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), U1(z4, z5, member_in(z5)))
U9¹(z0, .(z1, z2), .(p(x4, z0, x5, l), z4), member_out(p(x4, z0, x5, l), .(p(x4, z0, x5, l), z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(x4, z0, x5, l), z4))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), member_out(p(z4, z1, z5, r), .(p(z4, z1, z5, r), z6)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U5¹(z0, z1, .(z2, z3), member_out(p(x3, z1, x4, r), .(z2, z3))) → TURING_IN(t(.(x4, z0), space, []), .(z2, z3)) we obtained the following new rules:

U5¹(.(z0, z1), space, .(p(z2, z3, z0, r), z4), member_out(p(x4, space, x5, r), .(p(z2, z3, z0, r), z4))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z2, z3, z0, r), z4))
U5¹(.(z0, z1), space, .(p(x4, space, x5, r), z3), member_out(p(x4, space, x5, r), .(p(x4, space, x5, r), z3))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(x4, space, x5, r), z3))
U5¹(.(z0, z1), z2, .(p(z3, z2, z0, r), z5), member_out(p(z3, z2, z0, r), .(p(z3, z2, z0, r), z5))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z2, z0, r), z5))
U5¹(.(z0, z1), z2, .(p(z3, z4, z0, r), z5), member_out(p(x4, z2, x5, r), .(p(z3, z4, z0, r), z5))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
U5¹(.(z0, z1), space, .(z2, z3), member_out(p(x4, space, x5, r), .(z2, z3))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z2, z3))
U5¹(.(z0, z1), z2, .(p(x4, z2, x5, r), z4), member_out(p(x4, z2, x5, r), .(p(x4, z2, x5, r), z4))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(x4, z2, x5, r), z4))
U5¹(.(z0, z1), z2, .(z3, z4), member_out(p(x4, z2, x5, r), .(z3, z4))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z3, z4))
U5¹(.(z0, z1), space, .(p(z2, space, z0, r), z4), member_out(p(z2, space, z0, r), .(p(z2, space, z0, r), z4))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z2, space, z0, r), z4))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Instantiation

                                                                                      ↳ QDP

                                                                                        ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), U1(z2, z3, member_in(z3)))
U9¹(space, .(z0, z1), .(p(x4, space, x5, l), z3), member_out(p(x4, space, x5, l), .(p(x4, space, x5, l), z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(x4, space, x5, l), z3))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), member_out(p(z4, z2, z5, l), .(p(z4, z2, z5, l), z6)))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), member_out(z4, .(z4, z5)))
U5¹(.(z0, z1), space, .(p(x2, space, x3, r), z3), member_out(p(x2, space, x3, r), .(p(x2, space, x3, r), z3))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x2, space, x3, r), z3))
U5¹(.(z0, z1), z2, .(p(z3, z4, z0, r), z5), member_out(p(x4, z2, x5, r), .(p(z3, z4, z0, r), z5))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
U3¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z1, x6, r), .(z4, z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
U9¹(z0, .(z1, z2), .(p(z3, z0, z1, l), z5), member_out(p(z3, z0, z1, l), .(p(z3, z0, z1, l), z5))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z0, z1, l), z5))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), U1(z2, z3, member_in(z3)))
U9¹(z0, .(z1, z2), .(z3, z4), member_out(p(x4, z0, x5, l), .(z3, z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
U5¹(.(z0, z1), z2, .(p(x2, z2, x3, r), z4), member_out(p(x2, z2, x3, r), .(p(x2, z2, x3, r), z4))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x2, z2, x3, r), z4))
U9¹(z0, .(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x4, z0, x5, l), .(p(z3, z4, z1, l), z5))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
U5¹(.(z0, z1), space, .(p(z2, z3, z0, r), z4), member_out(p(x4, space, x5, r), .(p(z2, z3, z0, r), z4))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z2, z3, z0, r), z4))
U7¹(z0, z1, z2, z3, .(p(x5, z2, x6, l), z5), member_out(p(x5, z2, x6, l), .(p(x5, z2, x6, l), z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x5, z2, x6, l), z5))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), member_out(p(z2, z1, z3, r), .(p(z2, z1, z3, r), z4)))
U7¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z2, x6, l), .(z4, z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
U9¹(space, .(z0, z1), .(p(z2, space, z0, l), z4), member_out(p(z2, space, z0, l), .(p(z2, space, z0, l), z4))) → TURING_IN(t([], space, .(z0, .(z0, z1))), .(p(z2, space, z0, l), z4))
U9¹(space, .(z0, z1), .(p(z2, z3, z0, l), z4), member_out(p(x4, space, x5, l), .(p(z2, z3, z0, l), z4))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(z2, z3, z0, l), z4))
U5¹(.(z0, z1), space, .(z2, z3), member_out(p(x4, space, x5, r), .(z2, z3))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z2, z3))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), U1(p(z4, z1, z5, r), z6, member_in(z6)))
U5¹(.(z0, z1), z2, .(z3, z4), member_out(p(x4, z2, x5, r), .(z3, z4))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z3, z4))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), U1(z4, z5, member_in(z5)))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), member_out(z2, .(z2, z3)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), U1(p(z4, z2, z5, l), z6, member_in(z6)))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), member_out(z4, .(z4, z5)))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), member_out(p(z2, z0, z3, l), .(p(z2, z0, z3, l), z4)))
U9¹(space, .(z0, z1), .(z2, z3), member_out(p(x4, space, x5, l), .(z2, z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(z2, z3))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), U1(p(z2, z0, z3, l), z4, member_in(z4)))
TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), member_out(z2, .(z2, z3)))
U3¹(z0, z1, z2, z3, .(p(x5, z1, x6, r), z5), member_out(p(x5, z1, x6, r), .(p(x5, z1, x6, r), z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x5, z1, x6, r), z5))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
U5¹(.(z0, z1), space, .(p(z2, space, z0, r), z4), member_out(p(z2, space, z0, r), .(p(z2, space, z0, r), z4))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z2, space, z0, r), z4))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), U1(p(z2, z1, z3, r), z4, member_in(z4)))
U5¹(.(z0, z1), z2, .(p(z3, z2, z0, r), z5), member_out(p(z3, z2, z0, r), .(p(z3, z2, z0, r), z5))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z2, z0, r), z5))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), U1(z4, z5, member_in(z5)))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), member_out(p(z4, z1, z5, r), .(p(z4, z1, z5, r), z6)))
U9¹(z0, .(z1, z2), .(p(x4, z0, x5, l), z4), member_out(p(x4, z0, x5, l), .(p(x4, z0, x5, l), z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(x4, z0, x5, l), z4))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1))) we obtained the following new rules:

TURING_IN(t(x0, x1, .(x2, x3)), .(p(y_6, y_7, y_8, r), x5)) → U3¹(x0, x1, x2, x3, .(p(y_6, y_7, y_8, r), x5), member_out(p(y_6, y_7, y_8, r), .(p(y_6, y_7, y_8, r), x5)))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Instantiation

                                                                                      ↳ QDP

                                                                                        ↳ ForwardInstantiation

                                                                                          ↳ QDP

                                                                                            ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

U9¹(space, .(z0, z1), .(p(x4, space, x5, l), z3), member_out(p(x4, space, x5, l), .(p(x4, space, x5, l), z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(x4, space, x5, l), z3))
TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), U1(z2, z3, member_in(z3)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), member_out(p(z4, z2, z5, l), .(p(z4, z2, z5, l), z6)))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), member_out(z4, .(z4, z5)))
U5¹(.(z0, z1), space, .(p(x2, space, x3, r), z3), member_out(p(x2, space, x3, r), .(p(x2, space, x3, r), z3))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x2, space, x3, r), z3))
U9¹(z0, .(z1, z2), .(p(z3, z0, z1, l), z5), member_out(p(z3, z0, z1, l), .(p(z3, z0, z1, l), z5))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z0, z1, l), z5))
U3¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z1, x6, r), .(z4, z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
U5¹(.(z0, z1), z2, .(p(z3, z4, z0, r), z5), member_out(p(x4, z2, x5, r), .(p(z3, z4, z0, r), z5))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
U5¹(.(z0, z1), z2, .(p(x2, z2, x3, r), z4), member_out(p(x2, z2, x3, r), .(p(x2, z2, x3, r), z4))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x2, z2, x3, r), z4))
U9¹(z0, .(z1, z2), .(z3, z4), member_out(p(x4, z0, x5, l), .(z3, z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), U1(z2, z3, member_in(z3)))
U9¹(z0, .(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x4, z0, x5, l), .(p(z3, z4, z1, l), z5))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
U7¹(z0, z1, z2, z3, .(p(x5, z2, x6, l), z5), member_out(p(x5, z2, x6, l), .(p(x5, z2, x6, l), z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x5, z2, x6, l), z5))
U5¹(.(z0, z1), space, .(p(z2, z3, z0, r), z4), member_out(p(x4, space, x5, r), .(p(z2, z3, z0, r), z4))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z2, z3, z0, r), z4))
U7¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z2, x6, l), .(z4, z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), member_out(p(z2, z1, z3, r), .(p(z2, z1, z3, r), z4)))
U9¹(space, .(z0, z1), .(p(z2, space, z0, l), z4), member_out(p(z2, space, z0, l), .(p(z2, space, z0, l), z4))) → TURING_IN(t([], space, .(z0, .(z0, z1))), .(p(z2, space, z0, l), z4))
U9¹(space, .(z0, z1), .(p(z2, z3, z0, l), z4), member_out(p(x4, space, x5, l), .(p(z2, z3, z0, l), z4))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(z2, z3, z0, l), z4))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), U1(p(z4, z1, z5, r), z6, member_in(z6)))
U5¹(.(z0, z1), space, .(z2, z3), member_out(p(x4, space, x5, r), .(z2, z3))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z2, z3))
U5¹(.(z0, z1), z2, .(z3, z4), member_out(p(x4, z2, x5, r), .(z3, z4))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z3, z4))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), U1(z4, z5, member_in(z5)))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), member_out(z2, .(z2, z3)))
TURING_IN(t(x0, x1, .(x2, x3)), .(p(y_6, y_7, y_8, r), x5)) → U3¹(x0, x1, x2, x3, .(p(y_6, y_7, y_8, r), x5), member_out(p(y_6, y_7, y_8, r), .(p(y_6, y_7, y_8, r), x5)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), U1(p(z4, z2, z5, l), z6, member_in(z6)))
U9¹(space, .(z0, z1), .(z2, z3), member_out(p(x4, space, x5, l), .(z2, z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(z2, z3))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), member_out(p(z2, z0, z3, l), .(p(z2, z0, z3, l), z4)))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), member_out(z4, .(z4, z5)))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), U1(p(z2, z0, z3, l), z4, member_in(z4)))
TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), member_out(z2, .(z2, z3)))
U3¹(z0, z1, z2, z3, .(p(x5, z1, x6, r), z5), member_out(p(x5, z1, x6, r), .(p(x5, z1, x6, r), z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x5, z1, x6, r), z5))
U5¹(.(z0, z1), space, .(p(z2, space, z0, r), z4), member_out(p(z2, space, z0, r), .(p(z2, space, z0, r), z4))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z2, space, z0, r), z4))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1)))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), U1(p(z2, z1, z3, r), z4, member_in(z4)))
U5¹(.(z0, z1), z2, .(p(z3, z2, z0, r), z5), member_out(p(z3, z2, z0, r), .(p(z3, z2, z0, r), z5))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z2, z0, r), z5))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), U1(z4, z5, member_in(z5)))
U9¹(z0, .(z1, z2), .(p(x4, z0, x5, l), z4), member_out(p(x4, z0, x5, l), .(p(x4, z0, x5, l), z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(x4, z0, x5, l), z4))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), member_out(p(z4, z1, z5, r), .(p(z4, z1, z5, r), z6)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), member_out(x0, .(x0, x1))) we obtained the following new rules:

TURING_IN(t(.(x0, x1), x2, x3), .(p(y_4, y_5, y_6, l), x5)) → U7¹(x0, x1, x2, x3, .(p(y_4, y_5, y_6, l), x5), member_out(p(y_4, y_5, y_6, l), .(p(y_4, y_5, y_6, l), x5)))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Instantiation

                                                                                      ↳ QDP

                                                                                        ↳ ForwardInstantiation

                                                                                          ↳ QDP

                                                                                            ↳ ForwardInstantiation

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), U1(z2, z3, member_in(z3)))
U9¹(space, .(z0, z1), .(p(x4, space, x5, l), z3), member_out(p(x4, space, x5, l), .(p(x4, space, x5, l), z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(x4, space, x5, l), z3))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), member_out(p(z4, z2, z5, l), .(p(z4, z2, z5, l), z6)))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), member_out(z4, .(z4, z5)))
U5¹(.(z0, z1), space, .(p(x2, space, x3, r), z3), member_out(p(x2, space, x3, r), .(p(x2, space, x3, r), z3))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x2, space, x3, r), z3))
U5¹(.(z0, z1), z2, .(p(z3, z4, z0, r), z5), member_out(p(x4, z2, x5, r), .(p(z3, z4, z0, r), z5))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
U3¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z1, x6, r), .(z4, z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
U9¹(z0, .(z1, z2), .(p(z3, z0, z1, l), z5), member_out(p(z3, z0, z1, l), .(p(z3, z0, z1, l), z5))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z0, z1, l), z5))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), U1(z2, z3, member_in(z3)))
U9¹(z0, .(z1, z2), .(z3, z4), member_out(p(x4, z0, x5, l), .(z3, z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
U5¹(.(z0, z1), z2, .(p(x2, z2, x3, r), z4), member_out(p(x2, z2, x3, r), .(p(x2, z2, x3, r), z4))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x2, z2, x3, r), z4))
U9¹(z0, .(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x4, z0, x5, l), .(p(z3, z4, z1, l), z5))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
U5¹(.(z0, z1), space, .(p(z2, z3, z0, r), z4), member_out(p(x4, space, x5, r), .(p(z2, z3, z0, r), z4))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z2, z3, z0, r), z4))
U7¹(z0, z1, z2, z3, .(p(x5, z2, x6, l), z5), member_out(p(x5, z2, x6, l), .(p(x5, z2, x6, l), z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x5, z2, x6, l), z5))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), member_out(p(z2, z1, z3, r), .(p(z2, z1, z3, r), z4)))
U7¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z2, x6, l), .(z4, z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
U9¹(space, .(z0, z1), .(p(z2, space, z0, l), z4), member_out(p(z2, space, z0, l), .(p(z2, space, z0, l), z4))) → TURING_IN(t([], space, .(z0, .(z0, z1))), .(p(z2, space, z0, l), z4))
U9¹(space, .(z0, z1), .(p(z2, z3, z0, l), z4), member_out(p(x4, space, x5, l), .(p(z2, z3, z0, l), z4))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(z2, z3, z0, l), z4))
U5¹(.(z0, z1), space, .(z2, z3), member_out(p(x4, space, x5, r), .(z2, z3))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z2, z3))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), U1(p(z4, z1, z5, r), z6, member_in(z6)))
U5¹(.(z0, z1), z2, .(z3, z4), member_out(p(x4, z2, x5, r), .(z3, z4))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z3, z4))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), U1(z4, z5, member_in(z5)))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), member_out(z2, .(z2, z3)))
TURING_IN(t(x0, x1, .(x2, x3)), .(p(y_6, y_7, y_8, r), x5)) → U3¹(x0, x1, x2, x3, .(p(y_6, y_7, y_8, r), x5), member_out(p(y_6, y_7, y_8, r), .(p(y_6, y_7, y_8, r), x5)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), U1(p(z4, z2, z5, l), z6, member_in(z6)))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), member_out(z4, .(z4, z5)))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), member_out(p(z2, z0, z3, l), .(p(z2, z0, z3, l), z4)))
U9¹(space, .(z0, z1), .(z2, z3), member_out(p(x4, space, x5, l), .(z2, z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(z2, z3))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), U1(p(z2, z0, z3, l), z4, member_in(z4)))
TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), member_out(z2, .(z2, z3)))
U3¹(z0, z1, z2, z3, .(p(x5, z1, x6, r), z5), member_out(p(x5, z1, x6, r), .(p(x5, z1, x6, r), z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x5, z1, x6, r), z5))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
U5¹(.(z0, z1), space, .(p(z2, space, z0, r), z4), member_out(p(z2, space, z0, r), .(p(z2, space, z0, r), z4))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z2, space, z0, r), z4))
TURING_IN(t(.(x0, x1), x2, x3), .(p(y_4, y_5, y_6, l), x5)) → U7¹(x0, x1, x2, x3, .(p(y_4, y_5, y_6, l), x5), member_out(p(y_4, y_5, y_6, l), .(p(y_4, y_5, y_6, l), x5)))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), U1(p(z2, z1, z3, r), z4, member_in(z4)))
U5¹(.(z0, z1), z2, .(p(z3, z2, z0, r), z5), member_out(p(z3, z2, z0, r), .(p(z3, z2, z0, r), z5))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z2, z0, r), z5))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), U1(z4, z5, member_in(z5)))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), member_out(p(z4, z1, z5, r), .(p(z4, z1, z5, r), z6)))
U9¹(z0, .(z1, z2), .(p(x4, z0, x5, l), z4), member_out(p(x4, z0, x5, l), .(p(x4, z0, x5, l), z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(x4, z0, x5, l), z4))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), member_out(z4, .(z4, z5))) we obtained the following new rules:

TURING_IN(t([], x0, .(x1, x2)), .(p(y_3, y_4, y_5, l), x4)) → U9¹(x0, .(x1, x2), .(p(y_3, y_4, y_5, l), x4), member_out(p(y_3, y_4, y_5, l), .(p(y_3, y_4, y_5, l), x4)))
TURING_IN(t([], space, .(x1, x2)), .(p(y_2, space, y_3, l), x4)) → U9¹(space, .(x1, x2), .(p(y_2, space, y_3, l), x4), member_out(p(y_2, space, y_3, l), .(p(y_2, space, y_3, l), x4)))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Instantiation

                                                                                      ↳ QDP

                                                                                        ↳ ForwardInstantiation

                                                                                          ↳ QDP

                                                                                            ↳ ForwardInstantiation

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

U9¹(space, .(z0, z1), .(p(x4, space, x5, l), z3), member_out(p(x4, space, x5, l), .(p(x4, space, x5, l), z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(x4, space, x5, l), z3))
TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), U1(z2, z3, member_in(z3)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), member_out(p(z4, z2, z5, l), .(p(z4, z2, z5, l), z6)))
U5¹(.(z0, z1), space, .(p(x2, space, x3, r), z3), member_out(p(x2, space, x3, r), .(p(x2, space, x3, r), z3))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x2, space, x3, r), z3))
U9¹(z0, .(z1, z2), .(p(z3, z0, z1, l), z5), member_out(p(z3, z0, z1, l), .(p(z3, z0, z1, l), z5))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z0, z1, l), z5))
U3¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z1, x6, r), .(z4, z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
U5¹(.(z0, z1), z2, .(p(z3, z4, z0, r), z5), member_out(p(x4, z2, x5, r), .(p(z3, z4, z0, r), z5))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
TURING_IN(t([], space, .(x1, x2)), .(p(y_2, space, y_3, l), x4)) → U9¹(space, .(x1, x2), .(p(y_2, space, y_3, l), x4), member_out(p(y_2, space, y_3, l), .(p(y_2, space, y_3, l), x4)))
U5¹(.(z0, z1), z2, .(p(x2, z2, x3, r), z4), member_out(p(x2, z2, x3, r), .(p(x2, z2, x3, r), z4))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x2, z2, x3, r), z4))
U9¹(z0, .(z1, z2), .(z3, z4), member_out(p(x4, z0, x5, l), .(z3, z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), U1(z2, z3, member_in(z3)))
U9¹(z0, .(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x4, z0, x5, l), .(p(z3, z4, z1, l), z5))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t([], x0, .(x1, x2)), .(p(y_3, y_4, y_5, l), x4)) → U9¹(x0, .(x1, x2), .(p(y_3, y_4, y_5, l), x4), member_out(p(y_3, y_4, y_5, l), .(p(y_3, y_4, y_5, l), x4)))
U7¹(z0, z1, z2, z3, .(p(x5, z2, x6, l), z5), member_out(p(x5, z2, x6, l), .(p(x5, z2, x6, l), z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x5, z2, x6, l), z5))
U5¹(.(z0, z1), space, .(p(z2, z3, z0, r), z4), member_out(p(x4, space, x5, r), .(p(z2, z3, z0, r), z4))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z2, z3, z0, r), z4))
U7¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z2, x6, l), .(z4, z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), member_out(p(z2, z1, z3, r), .(p(z2, z1, z3, r), z4)))
U9¹(space, .(z0, z1), .(p(z2, space, z0, l), z4), member_out(p(z2, space, z0, l), .(p(z2, space, z0, l), z4))) → TURING_IN(t([], space, .(z0, .(z0, z1))), .(p(z2, space, z0, l), z4))
U9¹(space, .(z0, z1), .(p(z2, z3, z0, l), z4), member_out(p(x4, space, x5, l), .(p(z2, z3, z0, l), z4))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(z2, z3, z0, l), z4))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), U1(p(z4, z1, z5, r), z6, member_in(z6)))
U5¹(.(z0, z1), space, .(z2, z3), member_out(p(x4, space, x5, r), .(z2, z3))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z2, z3))
U5¹(.(z0, z1), z2, .(z3, z4), member_out(p(x4, z2, x5, r), .(z3, z4))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z3, z4))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), U1(z4, z5, member_in(z5)))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), member_out(z2, .(z2, z3)))
TURING_IN(t(x0, x1, .(x2, x3)), .(p(y_6, y_7, y_8, r), x5)) → U3¹(x0, x1, x2, x3, .(p(y_6, y_7, y_8, r), x5), member_out(p(y_6, y_7, y_8, r), .(p(y_6, y_7, y_8, r), x5)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), U1(p(z4, z2, z5, l), z6, member_in(z6)))
U9¹(space, .(z0, z1), .(z2, z3), member_out(p(x4, space, x5, l), .(z2, z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(z2, z3))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), member_out(p(z2, z0, z3, l), .(p(z2, z0, z3, l), z4)))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), member_out(z4, .(z4, z5)))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), U1(p(z2, z0, z3, l), z4, member_in(z4)))
TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), member_out(z2, .(z2, z3)))
U3¹(z0, z1, z2, z3, .(p(x5, z1, x6, r), z5), member_out(p(x5, z1, x6, r), .(p(x5, z1, x6, r), z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x5, z1, x6, r), z5))
U5¹(.(z0, z1), space, .(p(z2, space, z0, r), z4), member_out(p(z2, space, z0, r), .(p(z2, space, z0, r), z4))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z2, space, z0, r), z4))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(.(x0, x1), x2, x3), .(p(y_4, y_5, y_6, l), x5)) → U7¹(x0, x1, x2, x3, .(p(y_4, y_5, y_6, l), x5), member_out(p(y_4, y_5, y_6, l), .(p(y_4, y_5, y_6, l), x5)))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), U1(p(z2, z1, z3, r), z4, member_in(z4)))
U5¹(.(z0, z1), z2, .(p(z3, z2, z0, r), z5), member_out(p(z3, z2, z0, r), .(p(z3, z2, z0, r), z5))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z2, z0, r), z5))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), U1(z4, z5, member_in(z5)))
U9¹(z0, .(z1, z2), .(p(x4, z0, x5, l), z4), member_out(p(x4, z0, x5, l), .(p(x4, z0, x5, l), z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(x4, z0, x5, l), z4))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), member_out(p(z4, z1, z5, r), .(p(z4, z1, z5, r), z6)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), member_out(z2, .(z2, z3))) we obtained the following new rules:

TURING_IN(t([], space, .(x0, x1)), .(p(y_2, space, y_3, l), x3)) → U9¹(space, .(x0, x1), .(p(y_2, space, y_3, l), x3), member_out(p(y_2, space, y_3, l), .(p(y_2, space, y_3, l), x3)))
TURING_IN(t([], space, .(x0, x1)), .(p(y_3, y_4, y_5, l), x3)) → U9¹(space, .(x0, x1), .(p(y_3, y_4, y_5, l), x3), member_out(p(y_3, y_4, y_5, l), .(p(y_3, y_4, y_5, l), x3)))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Instantiation

                                                                                      ↳ QDP

                                                                                        ↳ ForwardInstantiation

                                                                                          ↳ QDP

                                                                                            ↳ ForwardInstantiation

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), U1(z2, z3, member_in(z3)))
U9¹(space, .(z0, z1), .(p(x4, space, x5, l), z3), member_out(p(x4, space, x5, l), .(p(x4, space, x5, l), z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(x4, space, x5, l), z3))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), member_out(p(z4, z2, z5, l), .(p(z4, z2, z5, l), z6)))
U5¹(.(z0, z1), space, .(p(x2, space, x3, r), z3), member_out(p(x2, space, x3, r), .(p(x2, space, x3, r), z3))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x2, space, x3, r), z3))
U5¹(.(z0, z1), z2, .(p(z3, z4, z0, r), z5), member_out(p(x4, z2, x5, r), .(p(z3, z4, z0, r), z5))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
U3¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z1, x6, r), .(z4, z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
U9¹(z0, .(z1, z2), .(p(z3, z0, z1, l), z5), member_out(p(z3, z0, z1, l), .(p(z3, z0, z1, l), z5))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z0, z1, l), z5))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), U1(z2, z3, member_in(z3)))
U9¹(z0, .(z1, z2), .(z3, z4), member_out(p(x4, z0, x5, l), .(z3, z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
U5¹(.(z0, z1), z2, .(p(x2, z2, x3, r), z4), member_out(p(x2, z2, x3, r), .(p(x2, z2, x3, r), z4))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x2, z2, x3, r), z4))
TURING_IN(t([], space, .(x1, x2)), .(p(y_2, space, y_3, l), x4)) → U9¹(space, .(x1, x2), .(p(y_2, space, y_3, l), x4), member_out(p(y_2, space, y_3, l), .(p(y_2, space, y_3, l), x4)))
TURING_IN(t([], space, .(x0, x1)), .(p(y_3, y_4, y_5, l), x3)) → U9¹(space, .(x0, x1), .(p(y_3, y_4, y_5, l), x3), member_out(p(y_3, y_4, y_5, l), .(p(y_3, y_4, y_5, l), x3)))
U9¹(z0, .(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x4, z0, x5, l), .(p(z3, z4, z1, l), z5))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t([], x0, .(x1, x2)), .(p(y_3, y_4, y_5, l), x4)) → U9¹(x0, .(x1, x2), .(p(y_3, y_4, y_5, l), x4), member_out(p(y_3, y_4, y_5, l), .(p(y_3, y_4, y_5, l), x4)))
U5¹(.(z0, z1), space, .(p(z2, z3, z0, r), z4), member_out(p(x4, space, x5, r), .(p(z2, z3, z0, r), z4))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z2, z3, z0, r), z4))
U7¹(z0, z1, z2, z3, .(p(x5, z2, x6, l), z5), member_out(p(x5, z2, x6, l), .(p(x5, z2, x6, l), z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x5, z2, x6, l), z5))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), member_out(p(z2, z1, z3, r), .(p(z2, z1, z3, r), z4)))
U7¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z2, x6, l), .(z4, z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
U9¹(space, .(z0, z1), .(p(z2, space, z0, l), z4), member_out(p(z2, space, z0, l), .(p(z2, space, z0, l), z4))) → TURING_IN(t([], space, .(z0, .(z0, z1))), .(p(z2, space, z0, l), z4))
U9¹(space, .(z0, z1), .(p(z2, z3, z0, l), z4), member_out(p(x4, space, x5, l), .(p(z2, z3, z0, l), z4))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(z2, z3, z0, l), z4))
U5¹(.(z0, z1), space, .(z2, z3), member_out(p(x4, space, x5, r), .(z2, z3))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z2, z3))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), U1(p(z4, z1, z5, r), z6, member_in(z6)))
U5¹(.(z0, z1), z2, .(z3, z4), member_out(p(x4, z2, x5, r), .(z3, z4))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z3, z4))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), U1(z4, z5, member_in(z5)))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), member_out(z2, .(z2, z3)))
TURING_IN(t(x0, x1, .(x2, x3)), .(p(y_6, y_7, y_8, r), x5)) → U3¹(x0, x1, x2, x3, .(p(y_6, y_7, y_8, r), x5), member_out(p(y_6, y_7, y_8, r), .(p(y_6, y_7, y_8, r), x5)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), U1(p(z4, z2, z5, l), z6, member_in(z6)))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), member_out(z4, .(z4, z5)))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), member_out(p(z2, z0, z3, l), .(p(z2, z0, z3, l), z4)))
U9¹(space, .(z0, z1), .(z2, z3), member_out(p(x4, space, x5, l), .(z2, z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(z2, z3))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), U1(p(z2, z0, z3, l), z4, member_in(z4)))
U3¹(z0, z1, z2, z3, .(p(x5, z1, x6, r), z5), member_out(p(x5, z1, x6, r), .(p(x5, z1, x6, r), z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x5, z1, x6, r), z5))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
U5¹(.(z0, z1), space, .(p(z2, space, z0, r), z4), member_out(p(z2, space, z0, r), .(p(z2, space, z0, r), z4))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z2, space, z0, r), z4))
TURING_IN(t(.(x0, x1), x2, x3), .(p(y_4, y_5, y_6, l), x5)) → U7¹(x0, x1, x2, x3, .(p(y_4, y_5, y_6, l), x5), member_out(p(y_4, y_5, y_6, l), .(p(y_4, y_5, y_6, l), x5)))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), U1(p(z2, z1, z3, r), z4, member_in(z4)))
U5¹(.(z0, z1), z2, .(p(z3, z2, z0, r), z5), member_out(p(z3, z2, z0, r), .(p(z3, z2, z0, r), z5))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z2, z0, r), z5))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), U1(z4, z5, member_in(z5)))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), member_out(p(z4, z1, z5, r), .(p(z4, z1, z5, r), z6)))
U9¹(z0, .(z1, z2), .(p(x4, z0, x5, l), z4), member_out(p(x4, z0, x5, l), .(p(x4, z0, x5, l), z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(x4, z0, x5, l), z4))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), member_out(z4, .(z4, z5))) we obtained the following new rules:

TURING_IN(t(.(x0, x1), x2, []), .(p(y_3, y_4, y_5, r), x4)) → U5¹(.(x0, x1), x2, .(p(y_3, y_4, y_5, r), x4), member_out(p(y_3, y_4, y_5, r), .(p(y_3, y_4, y_5, r), x4)))
TURING_IN(t(.(x0, x1), space, []), .(p(y_2, space, y_3, r), x4)) → U5¹(.(x0, x1), space, .(p(y_2, space, y_3, r), x4), member_out(p(y_2, space, y_3, r), .(p(y_2, space, y_3, r), x4)))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Instantiation

                                                                                      ↳ QDP

                                                                                        ↳ ForwardInstantiation

                                                                                          ↳ QDP

                                                                                            ↳ ForwardInstantiation

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ ForwardInstantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

U9¹(space, .(z0, z1), .(p(x4, space, x5, l), z3), member_out(p(x4, space, x5, l), .(p(x4, space, x5, l), z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(x4, space, x5, l), z3))
TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), U1(z2, z3, member_in(z3)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), member_out(p(z4, z2, z5, l), .(p(z4, z2, z5, l), z6)))
U5¹(.(z0, z1), space, .(p(x2, space, x3, r), z3), member_out(p(x2, space, x3, r), .(p(x2, space, x3, r), z3))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x2, space, x3, r), z3))
U9¹(z0, .(z1, z2), .(p(z3, z0, z1, l), z5), member_out(p(z3, z0, z1, l), .(p(z3, z0, z1, l), z5))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z0, z1, l), z5))
U3¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z1, x6, r), .(z4, z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
U5¹(.(z0, z1), z2, .(p(z3, z4, z0, r), z5), member_out(p(x4, z2, x5, r), .(p(z3, z4, z0, r), z5))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
TURING_IN(t([], space, .(x1, x2)), .(p(y_2, space, y_3, l), x4)) → U9¹(space, .(x1, x2), .(p(y_2, space, y_3, l), x4), member_out(p(y_2, space, y_3, l), .(p(y_2, space, y_3, l), x4)))
U5¹(.(z0, z1), z2, .(p(x2, z2, x3, r), z4), member_out(p(x2, z2, x3, r), .(p(x2, z2, x3, r), z4))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x2, z2, x3, r), z4))
U9¹(z0, .(z1, z2), .(z3, z4), member_out(p(x4, z0, x5, l), .(z3, z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), U1(z2, z3, member_in(z3)))
U9¹(z0, .(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x4, z0, x5, l), .(p(z3, z4, z1, l), z5))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t([], space, .(x0, x1)), .(p(y_3, y_4, y_5, l), x3)) → U9¹(space, .(x0, x1), .(p(y_3, y_4, y_5, l), x3), member_out(p(y_3, y_4, y_5, l), .(p(y_3, y_4, y_5, l), x3)))
TURING_IN(t([], x0, .(x1, x2)), .(p(y_3, y_4, y_5, l), x4)) → U9¹(x0, .(x1, x2), .(p(y_3, y_4, y_5, l), x4), member_out(p(y_3, y_4, y_5, l), .(p(y_3, y_4, y_5, l), x4)))
U7¹(z0, z1, z2, z3, .(p(x5, z2, x6, l), z5), member_out(p(x5, z2, x6, l), .(p(x5, z2, x6, l), z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x5, z2, x6, l), z5))
U5¹(.(z0, z1), space, .(p(z2, z3, z0, r), z4), member_out(p(x4, space, x5, r), .(p(z2, z3, z0, r), z4))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z2, z3, z0, r), z4))
U7¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z2, x6, l), .(z4, z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), member_out(p(z2, z1, z3, r), .(p(z2, z1, z3, r), z4)))
U9¹(space, .(z0, z1), .(p(z2, space, z0, l), z4), member_out(p(z2, space, z0, l), .(p(z2, space, z0, l), z4))) → TURING_IN(t([], space, .(z0, .(z0, z1))), .(p(z2, space, z0, l), z4))
U9¹(space, .(z0, z1), .(p(z2, z3, z0, l), z4), member_out(p(x4, space, x5, l), .(p(z2, z3, z0, l), z4))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(z2, z3, z0, l), z4))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), U1(p(z4, z1, z5, r), z6, member_in(z6)))
U5¹(.(z0, z1), space, .(z2, z3), member_out(p(x4, space, x5, r), .(z2, z3))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z2, z3))
U5¹(.(z0, z1), z2, .(z3, z4), member_out(p(x4, z2, x5, r), .(z3, z4))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z3, z4))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), U1(z4, z5, member_in(z5)))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), member_out(z2, .(z2, z3)))
TURING_IN(t(x0, x1, .(x2, x3)), .(p(y_6, y_7, y_8, r), x5)) → U3¹(x0, x1, x2, x3, .(p(y_6, y_7, y_8, r), x5), member_out(p(y_6, y_7, y_8, r), .(p(y_6, y_7, y_8, r), x5)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), U1(p(z4, z2, z5, l), z6, member_in(z6)))
U9¹(space, .(z0, z1), .(z2, z3), member_out(p(x4, space, x5, l), .(z2, z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(z2, z3))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), member_out(p(z2, z0, z3, l), .(p(z2, z0, z3, l), z4)))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), U1(p(z2, z0, z3, l), z4, member_in(z4)))
TURING_IN(t(.(x0, x1), space, []), .(p(y_2, space, y_3, r), x4)) → U5¹(.(x0, x1), space, .(p(y_2, space, y_3, r), x4), member_out(p(y_2, space, y_3, r), .(p(y_2, space, y_3, r), x4)))
U3¹(z0, z1, z2, z3, .(p(x5, z1, x6, r), z5), member_out(p(x5, z1, x6, r), .(p(x5, z1, x6, r), z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x5, z1, x6, r), z5))
U5¹(.(z0, z1), space, .(p(z2, space, z0, r), z4), member_out(p(z2, space, z0, r), .(p(z2, space, z0, r), z4))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z2, space, z0, r), z4))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
TURING_IN(t(.(x0, x1), x2, x3), .(p(y_4, y_5, y_6, l), x5)) → U7¹(x0, x1, x2, x3, .(p(y_4, y_5, y_6, l), x5), member_out(p(y_4, y_5, y_6, l), .(p(y_4, y_5, y_6, l), x5)))
TURING_IN(t(.(x0, x1), x2, []), .(p(y_3, y_4, y_5, r), x4)) → U5¹(.(x0, x1), x2, .(p(y_3, y_4, y_5, r), x4), member_out(p(y_3, y_4, y_5, r), .(p(y_3, y_4, y_5, r), x4)))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), U1(p(z2, z1, z3, r), z4, member_in(z4)))
U5¹(.(z0, z1), z2, .(p(z3, z2, z0, r), z5), member_out(p(z3, z2, z0, r), .(p(z3, z2, z0, r), z5))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z2, z0, r), z5))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), U1(z4, z5, member_in(z5)))
U9¹(z0, .(z1, z2), .(p(x4, z0, x5, l), z4), member_out(p(x4, z0, x5, l), .(p(x4, z0, x5, l), z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(x4, z0, x5, l), z4))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), member_out(p(z4, z1, z5, r), .(p(z4, z1, z5, r), z6)))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), member_out(z2, .(z2, z3))) we obtained the following new rules:

TURING_IN(t(.(x0, x1), space, []), .(p(y_3, y_4, y_5, r), x3)) → U5¹(.(x0, x1), space, .(p(y_3, y_4, y_5, r), x3), member_out(p(y_3, y_4, y_5, r), .(p(y_3, y_4, y_5, r), x3)))
TURING_IN(t(.(x0, x1), space, []), .(p(y_2, space, y_3, r), x3)) → U5¹(.(x0, x1), space, .(p(y_2, space, y_3, r), x3), member_out(p(y_2, space, y_3, r), .(p(y_2, space, y_3, r), x3)))

↳ Prolog

  ↳ PrologToPiTRSProof

  ↳ PrologToPiTRSProof

    ↳ PiTRS

      ↳ DependencyPairsProof

        ↳ PiDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ PiDP

              ↳ PiDP

                ↳ UsableRulesProof

                  ↳ PiDP

                    ↳ PiDPToQDPProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Narrowing

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Instantiation

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Instantiation

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Instantiation

                                                                                      ↳ QDP

                                                                                        ↳ ForwardInstantiation

                                                                                          ↳ QDP

                                                                                            ↳ ForwardInstantiation

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ ForwardInstantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

TURING_IN(t([], space, .(z5, z1)), .(z2, z3)) → U9¹(space, .(z5, z1), .(z2, z3), U1(z2, z3, member_in(z3)))
U9¹(space, .(z0, z1), .(p(x4, space, x5, l), z3), member_out(p(x4, space, x5, l), .(p(x4, space, x5, l), z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(x4, space, x5, l), z3))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), member_out(p(z4, z2, z5, l), .(p(z4, z2, z5, l), z6)))
U5¹(.(z0, z1), space, .(p(x2, space, x3, r), z3), member_out(p(x2, space, x3, r), .(p(x2, space, x3, r), z3))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x2, space, x3, r), z3))
U5¹(.(z0, z1), z2, .(p(z3, z4, z0, r), z5), member_out(p(x4, z2, x5, r), .(p(z3, z4, z0, r), z5))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z3, z4, z0, r), z5))
U3¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z1, x6, r), .(z4, z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(z4, z5))
U9¹(z0, .(z1, z2), .(p(z3, z0, z1, l), z5), member_out(p(z3, z0, z1, l), .(p(z3, z0, z1, l), z5))) → TURING_IN(t([], space, .(z1, .(z1, z2))), .(p(z3, z0, z1, l), z5))
TURING_IN(t(.(z5, z0), space, []), .(z2, z3)) → U5¹(.(z5, z0), space, .(z2, z3), U1(z2, z3, member_in(z3)))
U9¹(z0, .(z1, z2), .(z3, z4), member_out(p(x4, z0, x5, l), .(z3, z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(z3, z4))
U5¹(.(z0, z1), z2, .(p(x2, z2, x3, r), z4), member_out(p(x2, z2, x3, r), .(p(x2, z2, x3, r), z4))) → TURING_IN(t(.(x3, .(z0, z1)), space, []), .(p(x2, z2, x3, r), z4))
TURING_IN(t([], space, .(x1, x2)), .(p(y_2, space, y_3, l), x4)) → U9¹(space, .(x1, x2), .(p(y_2, space, y_3, l), x4), member_out(p(y_2, space, y_3, l), .(p(y_2, space, y_3, l), x4)))
TURING_IN(t([], space, .(x0, x1)), .(p(y_3, y_4, y_5, l), x3)) → U9¹(space, .(x0, x1), .(p(y_3, y_4, y_5, l), x3), member_out(p(y_3, y_4, y_5, l), .(p(y_3, y_4, y_5, l), x3)))
U9¹(z0, .(z1, z2), .(p(z3, z4, z1, l), z5), member_out(p(x4, z0, x5, l), .(p(z3, z4, z1, l), z5))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(z3, z4, z1, l), z5))
TURING_IN(t([], x0, .(x1, x2)), .(p(y_3, y_4, y_5, l), x4)) → U9¹(x0, .(x1, x2), .(p(y_3, y_4, y_5, l), x4), member_out(p(y_3, y_4, y_5, l), .(p(y_3, y_4, y_5, l), x4)))
U5¹(.(z0, z1), space, .(p(z2, z3, z0, r), z4), member_out(p(x4, space, x5, r), .(p(z2, z3, z0, r), z4))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(p(z2, z3, z0, r), z4))
U7¹(z0, z1, z2, z3, .(p(x5, z2, x6, l), z5), member_out(p(x5, z2, x6, l), .(p(x5, z2, x6, l), z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(p(x5, z2, x6, l), z5))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), member_out(p(z2, z1, z3, r), .(p(z2, z1, z3, r), z4)))
U7¹(z0, z1, z2, z3, .(z4, z5), member_out(p(x5, z2, x6, l), .(z4, z5))) → TURING_IN(t(z1, z0, .(x6, z3)), .(z4, z5))
U9¹(space, .(z0, z1), .(p(z2, space, z0, l), z4), member_out(p(z2, space, z0, l), .(p(z2, space, z0, l), z4))) → TURING_IN(t([], space, .(z0, .(z0, z1))), .(p(z2, space, z0, l), z4))
U9¹(space, .(z0, z1), .(p(z2, z3, z0, l), z4), member_out(p(x4, space, x5, l), .(p(z2, z3, z0, l), z4))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(p(z2, z3, z0, l), z4))
U5¹(.(z0, z1), space, .(z2, z3), member_out(p(x4, space, x5, r), .(z2, z3))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z2, z3))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), U1(p(z4, z1, z5, r), z6, member_in(z6)))
U5¹(.(z0, z1), z2, .(z3, z4), member_out(p(x4, z2, x5, r), .(z3, z4))) → TURING_IN(t(.(x5, .(z0, z1)), space, []), .(z3, z4))
TURING_IN(t(.(z7, z0), z2, []), .(z4, z5)) → U5¹(.(z7, z0), z2, .(z4, z5), U1(z4, z5, member_in(z5)))
TURING_IN(t(x0, x1, .(x2, x3)), .(p(y_6, y_7, y_8, r), x5)) → U3¹(x0, x1, x2, x3, .(p(y_6, y_7, y_8, r), x5), member_out(p(y_6, y_7, y_8, r), .(p(y_6, y_7, y_8, r), x5)))
TURING_IN(t([], z0, .(z5, z3)), .(p(z4, z2, z5, l), z6)) → U9¹(z0, .(z5, z3), .(p(z4, z2, z5, l), z6), U1(p(z4, z2, z5, l), z6, member_in(z6)))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), member_out(p(z2, z0, z3, l), .(p(z2, z0, z3, l), z4)))
U9¹(space, .(z0, z1), .(z2, z3), member_out(p(x4, space, x5, l), .(z2, z3))) → TURING_IN(t([], space, .(x5, .(z0, z1))), .(z2, z3))
TURING_IN(t([], space, .(z3, z1)), .(p(z2, z0, z3, l), z4)) → U9¹(space, .(z3, z1), .(p(z2, z0, z3, l), z4), U1(p(z2, z0, z3, l), z4, member_in(z4)))
TURING_IN(t(.(x0, x1), space, []), .(p(y_2, space, y_3, r), x4)) → U5¹(.(x0, x1), space, .(p(y_2, space, y_3, r), x4), member_out(p(y_2, space, y_3, r), .(p(y_2, space, y_3, r), x4)))
U3¹(z0, z1, z2, z3, .(p(x5, z1, x6, r), z5), member_out(p(x5, z1, x6, r), .(p(x5, z1, x6, r), z5))) → TURING_IN(t(.(x6, z0), z2, z3), .(p(x5, z1, x6, r), z5))
TURING_IN(t(.(y0, y1), y2, y3), .(x0, x1)) → U7¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))
U5¹(.(z0, z1), space, .(p(z2, space, z0, r), z4), member_out(p(z2, space, z0, r), .(p(z2, space, z0, r), z4))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z2, space, z0, r), z4))
TURING_IN(t(.(x0, x1), space, []), .(p(y_3, y_4, y_5, r), x3)) → U5¹(.(x0, x1), space, .(p(y_3, y_4, y_5, r), x3), member_out(p(y_3, y_4, y_5, r), .(p(y_3, y_4, y_5, r), x3)))
TURING_IN(t(.(x0, x1), x2, x3), .(p(y_4, y_5, y_6, l), x5)) → U7¹(x0, x1, x2, x3, .(p(y_4, y_5, y_6, l), x5), member_out(p(y_4, y_5, y_6, l), .(p(y_4, y_5, y_6, l), x5)))
TURING_IN(t(.(x0, x1), x2, []), .(p(y_3, y_4, y_5, r), x4)) → U5¹(.(x0, x1), x2, .(p(y_3, y_4, y_5, r), x4), member_out(p(y_3, y_4, y_5, r), .(p(y_3, y_4, y_5, r), x4)))
TURING_IN(t(.(z3, z0), space, []), .(p(z2, z1, z3, r), z4)) → U5¹(.(z3, z0), space, .(p(z2, z1, z3, r), z4), U1(p(z2, z1, z3, r), z4, member_in(z4)))
U5¹(.(z0, z1), z2, .(p(z3, z2, z0, r), z5), member_out(p(z3, z2, z0, r), .(p(z3, z2, z0, r), z5))) → TURING_IN(t(.(z0, .(z0, z1)), space, []), .(p(z3, z2, z0, r), z5))
TURING_IN(t([], z0, .(z7, z3)), .(z4, z5)) → U9¹(z0, .(z7, z3), .(z4, z5), U1(z4, z5, member_in(z5)))
TURING_IN(t(.(z5, z0), z2, []), .(p(z4, z1, z5, r), z6)) → U5¹(.(z5, z0), z2, .(p(z4, z1, z5, r), z6), member_out(p(z4, z1, z5, r), .(p(z4, z1, z5, r), z6)))
U9¹(z0, .(z1, z2), .(p(x4, z0, x5, l), z4), member_out(p(x4, z0, x5, l), .(p(x4, z0, x5, l), z4))) → TURING_IN(t([], space, .(x5, .(z1, z2))), .(p(x4, z0, x5, l), z4))
TURING_IN(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3¹(y0, y1, y2, y3, .(x0, x1), U1(x0, x1, member_in(x1)))

The TRS R consists of the following rules:

member_in(.(H, L)) → U1(H, L, member_in(L))
member_in(.(H, L)) → member_out(H, .(H, L))
U1(H, L, member_out(X, L)) → member_out(X, .(H, L))

The set Q consists of the following terms:

member_in(x0)
U1(x0, x1, x2)

We have to consider all (P,Q,R)-chains.